0

I have an image of a large number of elliptical objects against a dark background. The objects are oriented in many different directions. I need to extract them so that they are all oriented in the same direction (i.e., horizontally ) so that they can be tightly cropped.

I have successfully used findBlobs() and crop to extract the individual objects but the cropped images preserves their orientation in the original image. I have also successfully rotated the individual objects so that are horizontal but this usually chops off the ends of the objects.

Because I know the coordinates and the angle the major axis makes with the x axis of the original image, I have tried to step through each object's angle then use findBlobs() to crop only those blobs that have an angle =0.

I might be making this more difficult than it has to be. So I need some advice.

Here is the code: from SimpleCV import * from operator import itemgetter, attrgetter, methodcaller

def rotatedRectWithMaxArea(w, h, angle):
  """
  Given a rectangle of size wxh that has been rotated by 'angle' (in
  radians), computes the width and height of the largest possible
  axis-aligned rectangle (maximal area) within the rotated rectangle.
  http://stackoverflow.com/questions/16702966/rotate-image-and-crop-out-          black-borders
  """
  if w <= 0 or h <= 0:
    return 0,0

  width_is_longer = w >= h
  side_long, side_short = (w,h) if width_is_longer else (h,w)

  # since the solutions for angle, -angle and 180-angle are all the same,
  # if suffices to look at the first quadrant and the absolute values of     sin,cos:
  sin_a, cos_a = abs(math.sin(angle)), abs(math.cos(angle))
  if side_short <= 2.*sin_a*cos_a*side_long:
    # half constrained case: two crop corners touch the longer side,
    #   the other two corners are on the mid-line parallel to the longer line
    x = 0.5*side_short
    wr,hr = (x/sin_a,x/cos_a) if width_is_longer else (x/cos_a,x/sin_a)
  else:
    # fully constrained case: crop touches all 4 sides
    cos_2a = cos_a*cos_a - sin_a*sin_a
    wr,hr = (w*cos_a - h*sin_a)/cos_2a, (h*cos_a - w*sin_a)/cos_2a

  return wr,hr

Ellipses=Image("Elliptical.jpg")


#now find the location and angle of the blobs

blobs=Ellipses.findBlobs()
for b in blobs:
    r=round(b.angle(),0)
    [x,y]=b.coordinates()



#now that we know the angles and coordinates of each blob rotate the       original image and
#apply findBlobs iteratively   
Ak=0
for angle in range (0,len(r)):
    [L,W]=Ellipses.size()
    print ("Ellipse Image Length =", L, "Width=",W)
    Ellipses1=Image("Elliptical.jpg")
    Ellipses1r=Ellipses1.rotate(angle)
    [wr,lr]=rotatedRectWithMaxArea(W,L,angle)
    print ("largest dimensions w, l = ",round(wr,0),round(lr,0))
    Ellipses1r.crop(L/2,W/2,lr,wr,centered=True)
    Ellipses1r.save("cropped_rotated"+str(Ak)+".png") 
blobs1=Ellipses1.findBlobs()
Ak +=1
thiirane
  • 1
  • 2

1 Answers1

0

I successfully figured out how to crop a number of randomly oriented ellipses so that they were all horizontally oriented and uniformly cropped. It's probably not the most elegant approach but it works. I first found the maximum length and angle of the blobs

blobs=Ellipses.findBlobs()
k=0
x=[b for b in blobs]
y=[b for b in blobs]
r=[b for b in blobs]
bl=[b for b in blobs]
#bl[k]=b.length()+.2*b.length()
#set crop to the largest blob

bl[k]=b.length()
if [x[k],y[k]]==[blobs[-1].x,blobs[-1].y]:
    #print ("the largest blob has length =", bl[k])
    bigX=x[k]
    bigY=y[k]
    bigR=r[k]
    bigL=bl[k]


ar[k]=b.aspectRatio()
bw[k]=bl[k]*ar[k]

#print ("angle=",round(r[k],0),"and coordinates=",     
x[k],y[k],"length=",bl[k],"width=",bw[k])
k+=1bw=[b for b in blobs]
ar=[b for b in blobs]
#largest Blob is  
biggest=blobs[-1]
print ("the largest blob has length =", biggest)
for b in blobs:
    r[k]=round(b.angle(),0)
    [x[k],y[k]]=b.coordinates()

, then sizing a square crop based on the maximum blob. 

Ak=0
for b in blobs:
    #print "number of blobs=",len(blobs)
    angleset=r[Ak]

    Ellipses1=Image(FN)
    #rotate whole image to make target blob horizontal
    #print "blob length=",bl[Ak],"blob width=",bw[Ak]
    #print "blob aspect Ratio=",ar[Ak], "width=",bl[Ak]*ar[Ak]
    #print "blobs coordinates=", x[Ak],y[Ak],"b1 angle=",angleset
    #crops the individual blobs and saves to disk
Ellipses1.crop(x[Ak],y[Ak],bigL,bigL,centered=True).save("cropped"+str(angleset)+".png")
    #reads individual cropped blobs from disk
    Ellipses1c=Image("cropped"+str(angleset)+".png")
    [L,W]=Ellipses1c.size()

#print ("Ellipse1c Image Length =", L, "Width=",W)
#rotate the individual images so they are horizontal (co-linear with x axis), then saves to disk
Ellipses1c.rotate(angleset,point=(L/2,L/2)).save("rotated_cropped"+str(angleset)+".png")

Ak +=1

Next I rotated the blobs using the blob.angle and saved the images. 

for i in range(0,len(r)):
angleset=r[i]
Ellipses2c=Image("rotated_cropped"+str(angleset)+".png")
[L,W]=Ellipses2c.size()
print ("Ellipse2c Image Length =", L, "Width=",W)
blobs2=Ellipses2c.findBlobs()
for b in blobs2:
    Ellipses2c.crop(b).save("final_"+FN_prefix+str(angleset)+".png")

This provided a set of images that were suitable for classification. I hope this helps someone.

thiirane
  • 1
  • 2