Esempio n. 1
0
 def testGreyScale(self):
     '''Test BOOK - GreyScale'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         newRed = p.getRed() * 0.299
         newGreen = p.getGreen() * 0.587
         newBlue = p.getBlue() * 0.114
         luminance = int(newRed + newGreen + newBlue)
         p.setColor(Color(luminance, luminance, luminance))
     self.pict.write(OUTPUT + "testgreyscale.jpg")
     self.picttest1 = Picture(OUTPUT + "testgreyscale.jpg")
     self.picttest2 = Picture(PICTURES + "barb-greyscale.jpg")
     self.assertEqual(
         self.picttest1.getWidth(), self.picttest2.getWidth(),
         'Widths are not the same (%s != %s)' %
         (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(
         self.picttest1.getHeight(), self.picttest2.getHeight(),
         'Heights are not the same (%s != %s)' %
         (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(
                 self.picttest1.getBasicPixel(i, j),
                 self.picttest2.getBasicPixel(i, j),
                 'Pixels (%s, %s) do not match (%s != %s) - see output file testgreyscale.jpg'
                 % (i, j, self.picttest1.getBasicPixel(
                     i, j), self.picttest2.getBasicPixel(i, j)))
Esempio n. 2
0
 def testIncreaseRed(self):
     '''Test BOOK - Increase red (by 20%)'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         value = p.getRed()
         p.setRed(int(value * 1.2))
     self.pict.write(OUTPUT + "testincred.jpg")
     self.picttest1 = Picture(OUTPUT + "testincred.jpg")
     self.picttest2 = Picture(PICTURES + "barb-incred.jpg")
     self.assertEqual(
         self.picttest1.getWidth(), self.picttest2.getWidth(),
         'Widths are not the same (%s != %s)' %
         (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(
         self.picttest1.getHeight(), self.picttest2.getHeight(),
         'Heights are not the same (%s != %s)' %
         (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(
                 self.picttest1.getBasicPixel(i, j),
                 self.picttest2.getBasicPixel(i, j),
                 'Pixels (%s, %s) do not match (%s != %s) - see output file testincred.jpg'
                 % (i, j, self.picttest1.getBasicPixel(
                     i, j), self.picttest2.getBasicPixel(i, j)))
Esempio n. 3
0
 def testNegative(self):
     '''Test BOOK - Negative'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         red = p.getRed()
         green = p.getGreen()
         blue = p.getBlue()
         negcolor = Color(255 - red, 255 - green, 255 - blue)
         p.setColor(negcolor)
     self.pict.write(OUTPUT + "testnegative.jpg")
     self.picttest1 = Picture(OUTPUT + "testnegative.jpg")
     self.picttest2 = Picture(PICTURES + "barb-negative.jpg")
     self.assertEqual(
         self.picttest1.getWidth(), self.picttest2.getWidth(),
         'Widths are not the same (%s != %s)' %
         (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(
         self.picttest1.getHeight(), self.picttest2.getHeight(),
         'Heights are not the same (%s != %s)' %
         (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(
                 self.picttest1.getBasicPixel(i, j),
                 self.picttest2.getBasicPixel(i, j),
                 'Pixels (%s, %s) do not match (%s != %s) - see output file testnegative.jpg'
                 % (i, j, self.picttest1.getBasicPixel(
                     i, j), self.picttest2.getBasicPixel(i, j)))
Esempio n. 4
0
 def testDarken(self):
     '''Test BOOK - Darken'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         color = p.getColor()
         p.setColor(color.darker())
     self.pict.write(OUTPUT + "testdarken.jpg")
     self.picttest1 = Picture(OUTPUT + "testdarken.jpg")
     self.picttest2 = Picture(PICTURES + "barb-darken.jpg")
     self.assertEqual(
         self.picttest1.getWidth(), self.picttest2.getWidth(),
         'Widths are not the same (%s != %s)' %
         (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(
         self.picttest1.getHeight(), self.picttest2.getHeight(),
         'Heights are not the same (%s != %s)' %
         (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(
                 self.picttest1.getBasicPixel(i, j),
                 self.picttest2.getBasicPixel(i, j),
                 'Pixels (%s, %s) do not match (%s != %s) - see output file testdarken.jpg'
                 % (i, j, self.picttest1.getBasicPixel(
                     i, j), self.picttest2.getBasicPixel(i, j)))
Esempio n. 5
0
 def __init__(self, r, g=None, b=None):
     if b == None:
         if isinstance(r, awt.Color) or isinstance(r, Color):
             self.color = r
         else:
             val = Pixel.correctLevel(r)
             self.color = awt.Color(val, val, val)
     else:
         self.color = awt.Color(
             Pixel.correctLevel(r), Pixel.correctLevel(g), Pixel.correctLevel(b))
Esempio n. 6
0
def color_skin_regions(img_path, save_path):
    image = Image.open(img_path)
    pixels = image.load()
    width = image.size[0]
    height = image.size[1]
    for i in xrange(0, width):
        for j in xrange(0, height):
            pixel = Pixel(i, j, pixels[i,j][0], pixels[i, j][1], pixels[i, j][2])
            if pixel.is_skin():
                pixels[i, j] = (0, 0, 0)
    image.save(save_path)
Esempio n. 7
0
def color_skin_regions(img_path, save_path):
    image = Image.open(img_path)
    pixels = image.load()
    width = image.size[0]
    height = image.size[1]
    for i in xrange(0, width):
        for j in xrange(0, height):
            pixel = Pixel(i, j, pixels[i, j][0], pixels[i, j][1], pixels[i, j][2])
            if pixel.is_skin():
                pixels[i, j] = (0, 0, 0)
    image.save(save_path)
Esempio n. 8
0
def parseColorSchemes(fileName):
    df = pandas.read_csv(fileName,
                         usecols=["schemeLabel", "maskLabel", "r", "g", "b"],
                         dtype={
                             "schemeLabel": "str",
                             "maskLabel": "str",
                             "r": "int",
                             "g": "int",
                             "b": "int"
                         })
    numRows = len(df)

    myDict = dict()
    for index in range(numRows):
        schemeLabel = df.iloc[index]['schemeLabel']
        maskLabel = df.iloc[index]['maskLabel']
        pixel = Pixel.Pixel(df.iloc[index]['r'], df.iloc[index]['g'],
                            df.iloc[index]['b'], "RGB")

        if schemeLabel not in myDict.keys():
            myDict[schemeLabel] = ColorScheme.ColorScheme(schemeLabel)
        myDict[schemeLabel].addLabelPixel(maskLabel, pixel)

    colorSchemes = []
    for value in myDict.values():
        colorSchemes.append(value)
    return colorSchemes
Esempio n. 9
0
def main():
    pl = []
    p1 = Pixel.Pixel(0, 0, 0)
    p2 = Pixel.Pixel(0, 0, 0)
    p3 = Pixel.Pixel(0, 0, 0)
    p4 = Pixel.Pixel(31, 57, 219)
    p5 = Pixel.Pixel(31, 57, 219)
    p6 = Pixel.Pixel(31, 57, 219)
    p7 = Pixel.Pixel(0, 0, 0)
    p8 = Pixel.Pixel(0, 0, 0)
    p9 = Pixel.Pixel(0, 0, 0)
    p10 = Pixel.Pixel(255, 255, 255)
    pl.extend([p1, p2, p3, p4, p5, p6, p7, p8, p9, p10])
    k = Kernel(pl)
    print k.__dict__
    return k
Esempio n. 10
0
 def testDistance(self):
     '''Test Book - Color distances'''
     self.color1 = Color(81, 63, 51)
     self.color2 = Color(255, 51, 51)
     self.distance = Pixel.colorDistance(self.color1, self.color2)
     self.assertEqual(self.distance, 174.41330224498358, 'Distances: %s != %s' % (
         self.distance, 174.41330224498358))
Esempio n. 11
0
 def testDistance(self):
     '''Test Book - Color distances'''
     self.color1 = Color(81, 63, 51)
     self.color2 = Color(255, 51, 51)
     self.distance = Pixel.colorDistance(self.color1, self.color2)
     self.assertEqual(
         self.distance, 174.41330224498358,
         'Distances: %s != %s' % (self.distance, 174.41330224498358))
Esempio n. 12
0
 def testIncreaseRed(self):
     '''Test BOOK - Increase red (by 20%)'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         value = p.getRed()
         p.setRed(int(value * 1.2))
     self.pict.write(OUTPUT + "testincred.jpg")
     self.picttest1 = Picture(OUTPUT + "testincred.jpg")
     self.picttest2 = Picture(PICTURES + "barb-incred.jpg")
     self.assertEqual(self.picttest1.getWidth(), self.picttest2.getWidth(
     ), 'Widths are not the same (%s != %s)' % (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(self.picttest1.getHeight(), self.picttest2.getHeight(
     ), 'Heights are not the same (%s != %s)' % (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(
                 i, j), 'Pixels (%s, %s) do not match (%s != %s) - see output file testincred.jpg' % (i, j, self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(i, j)))
Esempio n. 13
0
    def create_pixel_array(self, img):
        pixels = []
        for line in range(0, self.height):
            for column in range(0, self.width):
                pixel = Pixel.Pixel(line, column,
                                    True if img[line][column] == 1 else False)
                pixels.append(pixel)

        return pixels
Esempio n. 14
0
 def __init__(self, elevation, terrain, x, y, goalX, goalY):
     self.elevation = elevation
     self.terrain = terrain
     self.x = x
     self.y = y
     self.goalX = goalX
     self.goalY = goalY
     self.priority = (((goalX - x)**2 +
                       (goalY - y)**2)**(1 / 2)) * Pixel.Diag()
Esempio n. 15
0
 def testDarken(self):
     '''Test BOOK - Darken'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         color = p.getColor()
         p.setColor(color.darker())
     self.pict.write(OUTPUT + "testdarken.jpg")
     self.picttest1 = Picture(OUTPUT + "testdarken.jpg")
     self.picttest2 = Picture(PICTURES + "barb-darken.jpg")
     self.assertEqual(self.picttest1.getWidth(), self.picttest2.getWidth(
     ), 'Widths are not the same (%s != %s)' % (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(self.picttest1.getHeight(), self.picttest2.getHeight(
     ), 'Heights are not the same (%s != %s)' % (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(
                 i, j), 'Pixels (%s, %s) do not match (%s != %s) - see output file testdarken.jpg' % (i, j, self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(i, j)))
 def setKernelsandRGB(self, show=False):
     '''
     For each entry in self.cobs, it will open the file with that name in repDirectory.
     The file is a csv file of the format "accessionName, Kernel, R, G, B". This function will return a list of
     ints that correspond to the number of kernels that are associated with the Cob file.
     '''
     print "Creating Kernels and Pixels"
     progressBar = 0
     for key in self.cobs:
         progressBar += 1
         kernelList = []
         filePath = self.repDirectory + "/" + key + ".tif.csv"
         with open(filePath) as csvFile:
             csvReader = csv.reader(csvFile)
             csvList = list(csvReader)
             print "Cob: ", progressBar, "/", len(self.cobs)
             listofpixels = []
             currentKernel = 1
             for line in csvList:
                 try:
                     if line[0] == 'Image':
                         pass
                     elif int(line[1]) != currentKernel and line[4] != '':
                         kernelList.append(
                             Kernel.Kernel(listofpixels,
                                           name=currentKernel))
                         if show == True:
                             print "Kernel: %s" % currentKernel
                         listofpixels = []
                         currentKernel = int(line[1])
                         currentPixel = Pixel.Pixel(int(line[2]),
                                                    int(line[3]),
                                                    int(line[4]))
                         listofpixels.append(currentPixel)
                     elif int(line[1]) == currentKernel:
                         currentPixel = Pixel.Pixel(int(line[2]),
                                                    int(line[3]),
                                                    int(line[4]))
                         listofpixels.append(currentPixel)
                 except:
                     IndexError
         self.cobs[key] = Cob.Cob(kernelList)
         print "Kernel's Initialized for %s" % key
     print "All Cob's Initialized"
Esempio n. 17
0
def A_star(init):
    #a* search
    pq = []
    costs = {}
    visited = []
    print(init)
    costs[init] = 0
    heapq.heappush(pq, (init.priority, init))
    path = []
    parents = {}
    parents[init] = None
    while True:
        state = heapq.heappop(pq)[1]
        if (state.isGoal()):
            print("finished")
            # build path
            while (state != None):
                path.append(state)
                state = parents[state]
            return path
            break
        for s in GetSuccessors(state):
            if not contains(visited, s):
                #print(s)
                visited.append(s)
                speed = 1
                if (float(s.elevation) > float(state.elevation)):
                    speed = float(s.elevation) / float(
                        state.elevation)  # slower uphill
                # movement in the y direction
                if (s.x == state.x):
                    costs[s] = costs[state] + (
                        1 / (s.terrain * speed)) * Pixel.Latitude()
                # movement in the x direction
                elif (s.y == state.y):
                    costs[s] = costs[state] + (
                        1 / (s.terrain * speed)) * Pixel.Longitude()
                # otherwise, diagonal movement
                else:
                    costs[s] = costs[state] + (
                        1 / (s.terrain * speed)) * Pixel.Diag()
                heapq.heappush(pq, (costs[s] + s.priority, s))
                parents[s] = state
Esempio n. 18
0
def processing(mode, pix, width, height, draw, image):
    print(str(mode + 1) + ". Image")
    pbar.start()
    for i in range(width):
        for j in range(height):
            pixel = Pixel.Pixel(*pix[i, j])
            draw.point((i, j), (pixel.modeget(mode)))
            pbar.update(i * j)
            del pixel
    image.save("Image" + str(mode + 1) + ".jpg", "JPEG")
    print('')
Esempio n. 19
0
def get_direction(val):
    switcher = {
        1: ("Northwest", Pixel.Diag()),
        2: ("North", Pixel.Latitude()),
        3: ("Northeast", Pixel.Diag()),
        4: ("West", Pixel.Longitude()),
        5: ("East", Pixel.Longitude()),
        6: ("Southwest", Pixel.Diag()),
        7: ("South", Pixel.Latitude()),
        8: ("Southeast", Pixel.Diag())
    }

    return switcher.get(val)
Esempio n. 20
0
def negative(mode, pix, width, height, draw, image):
    print(str(mode + 1) + ". Negative")
    pbar.start()
    for i in range(width):
        for j in range(height):
            pixel = Pixel.Pixel(*pix[i, j])
            red, green, blue = pixel.modeget(mode)
            draw.point((i, j), (255 - red, 255 - green, 255 - blue))
            pbar.update(i * j)
            del pixel
    image.save("Negative" + str(mode + 1) + ".jpg", "JPEG")
    print('')
Esempio n. 21
0
 def testGreyScale(self):
     '''Test BOOK - GreyScale'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         newRed = p.getRed() * 0.299
         newGreen = p.getGreen() * 0.587
         newBlue = p.getBlue() * 0.114
         luminance = int(newRed + newGreen + newBlue)
         p.setColor(Color(luminance, luminance, luminance))
     self.pict.write(OUTPUT + "testgreyscale.jpg")
     self.picttest1 = Picture(OUTPUT + "testgreyscale.jpg")
     self.picttest2 = Picture(PICTURES + "barb-greyscale.jpg")
     self.assertEqual(self.picttest1.getWidth(), self.picttest2.getWidth(
     ), 'Widths are not the same (%s != %s)' % (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(self.picttest1.getHeight(), self.picttest2.getHeight(
     ), 'Heights are not the same (%s != %s)' % (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(
                 i, j), 'Pixels (%s, %s) do not match (%s != %s) - see output file testgreyscale.jpg' % (i, j, self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(i, j)))
Esempio n. 22
0
    def update_pixel_array(self, img):
        for line in range(0, self.height):
            for column in range(0, self.width):
                pixel = Pixel.Pixel(line, column,
                                    True if img[line][column] == 1 else False)
                if pixel not in self.arrayPixelsImage:
                    self.arrayPixelsImage.append(pixel)
                elif pixel in self.arrayPixelsImage:
                    idx = self.arrayPixelsImage.index(pixel)
                    self.arrayPixelsImage[idx] = pixel

        self.arrayPixelsImage.sort(key=lambda k: [k.x, k.y])
Esempio n. 23
0
 def testNegative(self):
     '''Test BOOK - Negative'''
     Pixel.setWrapLevels(False)
     self.pict = Picture(PICTURES + "barbara.jpg")
     for p in self.pict.getPixels():
         red = p.getRed()
         green = p.getGreen()
         blue = p.getBlue()
         negcolor = Color(255 - red, 255 - green, 255 - blue)
         p.setColor(negcolor)
     self.pict.write(OUTPUT + "testnegative.jpg")
     self.picttest1 = Picture(OUTPUT + "testnegative.jpg")
     self.picttest2 = Picture(PICTURES + "barb-negative.jpg")
     self.assertEqual(self.picttest1.getWidth(), self.picttest2.getWidth(
     ), 'Widths are not the same (%s != %s)' % (self.picttest1.getWidth(), self.picttest2.getWidth()))
     self.assertEqual(self.picttest1.getHeight(), self.picttest2.getHeight(
     ), 'Heights are not the same (%s != %s)' % (self.picttest1.getHeight(), self.picttest2.getHeight()))
     for i in range(self.picttest1.getWidth()):
         for j in range(self.picttest1.getHeight()):
             self.assertEqual(self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(
                 i, j), 'Pixels (%s, %s) do not match (%s != %s) - see output file testnegative.jpg' % (i, j, self.picttest1.getBasicPixel(i, j), self.picttest2.getBasicPixel(i, j)))
Esempio n. 24
0
 def __init__(self, bitmap, wid, hi):
     self.wid = wid
     self.hi = hi
     result = []
     level = []
     for i in range(wid * hi):
         level.append(
             Pixel(blue=bitmap[i * 3],
                   green=bitmap[i * 3 + 1],
                   red=bitmap[i * 3 + 2]))
         if wid == len(level):
             result.insert(0, level)
             level = []
     self.bitmap = result
Esempio n. 25
0
def processImageRGBA(image: Image, mask: Mask, colorScheme: ColorScheme):
    result = Image.new("RGBA", image.size)

    for x in range(image.size[0]):
        for y in range(image.size[1]):
            p = image.getpixel((x, y))
            p_r, p_g, p_b, p_a = p
            pixel = Pixel.Pixel(p_r, p_g, p_b, "RGB")

            pixelLabel = mask.getLabel(pixel)
            tPixel = colorScheme.getPixel(pixelLabel)
            if pixelLabel != "":
                result.putpixel((x, y), (tPixel.r, tPixel.g, tPixel.b, p_a))
            else:  # if it doesn't map to any known values
                result.putpixel((x, y), p)

    return result
Esempio n. 26
0
def init():
    SCREEN.fill(BLACK)
    pygame.display.update()
    world = []
    for y in range(int(SCREEN_HEIGHT / PIXEL_SIZE)):
        row = []
        for x in range(int(SCREEN_WIDTH / PIXEL_SIZE)):
            pixel = Pixel.Pixel(SCREEN, x, y, PIXEL_SIZE)
            pixel.draw()
            row.append(pixel)
        world.append(row)

    user_pick(world)  # let user pick starting state

    # Draw a glider gun
    # for (y, x) in GLIDER_GUN: world[y][x].color = WHITE

    return world
Esempio n. 27
0
def parseMask(fileName):
    df = pandas.read_csv(fileName,
                         usecols=["label", "r", "g", "b"],
                         dtype={
                             "label": "str",
                             "r": "int",
                             "g": "int",
                             "b": "int"
                         })
    numRows = len(df)

    mask = Mask.Mask()

    for index in range(numRows):
        pixel = Pixel.Pixel(df.iloc[index]['r'], df.iloc[index]['g'],
                            df.iloc[index]['b'], "RGB")
        mask.addPixelLabel(df.iloc[index]['label'], pixel)

    return mask
Esempio n. 28
0
def parse(bitmap, wid, hi):
    """
    Parsing map to list of pixels
    :param bitmap:
    :param wid:
    :param hi:
    :return:
    """
    result = []
    level = []
    for i in range(wid * hi):
        level.append(
            Pixel(blue=bitmap[i * 3],
                  green=bitmap[i * 3 + 1],
                  red=bitmap[i * 3 + 2]))
        if wid == len(level):
            result.insert(0, level)
            level = []
    return result
Esempio n. 29
0
def decode(low_data):
    """
    Decodes image
    :param low_data:
    :return:
    """
    hex_str = low_data.hex()
    bits = "".join([
        "{0:08b}".format(int(hex_str[x:x + 2], base=16))
        for x in range(0, len(hex_str), 2)
    ])
    codes = decode_code(bits)
    differences = [x // 2 if x % 2 == 0 else -(x // 2) for x in codes]
    bitmap = [
        Pixel(int(differences[i + 2]), int(differences[i + 1]),
              int(differences[i])) for i in range(0, len(differences), 3)
    ]
    bitmap = diff_decode(bitmap)
    bitmap = convert_to_list(bitmap)
    return bytes(bitmap)
Esempio n. 30
0
def contains_nudity(image_path):
    image = Image.open(image_path)
    imgPixels = image.load()
    width = image.size[0]
    height = image.size[1]
    pixels = [ [None]*height for i in range(width) ]

    for i in xrange(0, width):
        for j in xrange(0, height):
            pixels[i][j] = Pixel(i, j, imgPixels[i,j][0], imgPixels[i,j][1], imgPixels[i,j][2])
    
    skin_pixels = []
    skin_regions = []
    create_skin_regions(pixels, skin_pixels, skin_regions, width, height)

    if len(skin_regions) < 3:
        return False
    skin_regions.sort(key = operator.attrgetter('size'), reverse=True)

    bounding_region = create_bounding_region(pixels, skin_regions, width, height)
    return analyze_regions(skin_pixels, skin_regions, bounding_region, width, height)
Esempio n. 31
0
def percolate(bitmap, x, y, high=False):
    """
    Filters upper,lower
    :param bitmap:
    :param x:
    :param y:
    :param high:
    :return:
    """
    w1 = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
    w2 = [[0, -1, 0], [-1, 5, -1], [0, -1, 0]]
    weights = w2 if high else w1
    pixel_org = Pixel(0, 0, 0)
    for i in range(-1, 2):
        for j in range(-1, 2):
            pixel_org += bitmap[x + i, y + j] * weights[i + 1][j + 1]
    weights_sum = sum([sum(level) for level in weights])
    if weights_sum <= 0:
        weights_sum = 1
    pixel_org = pixel_org // weights_sum
    setup_pixel(pixel_org)
    return pixel_org
Esempio n. 32
0
def setColorWrapAround(setting):
    Pixel.setWrapLevels(bool(setting))
Esempio n. 33
0
    def process_score_image(self):
        """

        :rtype: object
        """
        bms_factory = BMSFactoryTube.BMSFactory()

        notes = [[], [], [], [], [], [], []]  # レーン別のノーツの情報
        is_usable = [True, True]  # 長押しをいくつ追跡しているかをカウントする。

        img = cv2.imread(self.FILE_NAME)

        for i in range(0, self.LANE_NUM):
            self.states.append(PixelState(StateType.NONE, 0))

        #
        # ------- 画像解析開始 --------
        #

        for bar in range(1, self.BAR_NUM + 1):  # 小節に関するループ

            column_index = int((bar - 1) / self.BAR_NUM_PER_COLUMN)  # 何列目か

            for pixel_offset in range(0, self.BAR_LENGTH):  # ピクセル単位のループ(縦)

                # if bar == 11:
                #     tstr = "追跡状況:"
                #     for i in range(0, self.LANE_NUM):
                #         tstr += str(self.states[i].following_long_num) + ", "
                #     print(tstr)

                for lane_index in range(0, self.LANE_NUM):  # レーンに関するループ

                    offset_x = lane_index * self.LANE_WIDTH + column_index * self.COLUMN_WIDTH
                    offset_y = -(
                        (bar - 1) % self.BAR_NUM_PER_COLUMN) * self.BAR_LENGTH

                    lane_start_point = Point.sum(self.BASIC_START_POINT,
                                                 Point(offset_x, offset_y))
                    # print("bar, lane_index, startpoint")
                    # if bar == 1:
                    #     print(str(bar) + " " + str(lane_index) + "(" + str(lane_start_point.x) + ", " + str(lane_start_point.y) + ")")

                    bgr = img[int(lane_start_point.y) - pixel_offset,
                              int(lane_start_point.x)]
                    b = bgr[0]
                    g = bgr[1]
                    r = bgr[2]

                    # 追跡用に左右の色を取得(6が限度。7以上ずらすと真っ直ぐが追えなくなる)
                    left_bgr = img[int(lane_start_point.y) - pixel_offset,
                                   int(lane_start_point.x -
                                       self.LANE_WIDTH * 0.3)]
                    lb = left_bgr[0]
                    lg = left_bgr[1]
                    lr = left_bgr[2]

                    right_bgr = img[int(lane_start_point.y) - pixel_offset,
                                    int(lane_start_point.x +
                                        self.LANE_WIDTH * 0.3)]
                    rb = right_bgr[0]
                    rg = right_bgr[1]
                    rr = right_bgr[2]

                    lane_state = self.states[lane_index]

                    # 各ノーツを識別する
                    if lane_state.state == StateType.NONE:

                        if Pixel.is_tap_frame(b, g, r):
                            lane_state.state = StateType.IN_TAP
                            lane_state.from_pixel_index = pixel_offset + (
                                bar - 1) * self.BAR_LENGTH

                        elif Pixel.is_flick_frame(b, g, r):
                            lane_state.state = StateType.IN_PINK
                            lane_state.from_pixel_index = pixel_offset + (
                                bar - 1) * self.BAR_LENGTH

                        elif Pixel.is_green(b, g, r):
                            lane_state.state = StateType.IN_GREEN
                            lane_state.from_pixel_index = pixel_offset + (
                                bar - 1) * self.BAR_LENGTH

                        elif Pixel.is_middle_frame(b, g, r):
                            lane_state.state = StateType.IN_MIDDLE
                            lane_state.from_pixel_index = pixel_offset + (
                                bar - 1) * self.BAR_LENGTH

                        elif Pixel.is_yellow_frame(b, g, r):
                            lane_state.state = StateType.IN_YELLOW
                            lane_state.from_pixel_index = pixel_offset + (
                                bar - 1) * self.BAR_LENGTH

                    elif lane_state.state == StateType.IN_PINK:

                        # 一番下の次のピクセルの横の色から終点であるかを判断
                        is_flick_end = False
                        for pixel_x in range(
                                int(lane_start_point.x - self.LANE_WIDTH / 2),
                                int(lane_start_point.x + self.LANE_WIDTH / 2)):

                            bgr_t = img[int(lane_start_point.y) - pixel_offset,
                                        int(pixel_x)]
                            b_t = bgr_t[0]
                            g_t = bgr_t[1]
                            r_t = bgr_t[2]
                            bgr_t2 = img[int(lane_start_point.y) -
                                         pixel_offset - 2,
                                         int(pixel_x)]  # 鬼畜スライド用
                            b_t2 = bgr_t2[0]
                            g_t2 = bgr_t2[1]
                            r_t2 = bgr_t2[2]

                            if Pixel.is_connecting_green(
                                    b_t, g_t,
                                    r_t) or Pixel.is_connecting_green(
                                        b_t2, g_t2, r_t2):
                                is_flick_end = True
                                break

                        if is_flick_end:
                            lane_state.state = StateType.IN_FLICK_END
                        else:
                            lane_state.state = StateType.IN_FLICK

                    elif lane_state.state == StateType.IN_GREEN:

                        is_tap_end = False
                        for pixel_x in range(
                                int(lane_start_point.x - self.LANE_WIDTH / 2),
                                int(lane_start_point.x + self.LANE_WIDTH / 2)):

                            bgr_t = img[int(lane_start_point.y) - pixel_offset,
                                        int(pixel_x)]
                            b_t = bgr_t[0]
                            g_t = bgr_t[1]
                            r_t = bgr_t[2]
                            bgr_t2 = img[int(lane_start_point.y) -
                                         pixel_offset - 2,
                                         int(pixel_x)]  # 鬼畜スライド用
                            b_t2 = bgr_t2[0]
                            g_t2 = bgr_t2[1]
                            r_t2 = bgr_t2[2]
                            if Pixel.is_connecting_green(
                                    b_t, g_t,
                                    r_t) or Pixel.is_connecting_green(
                                        b_t2, g_t2, r_t2):
                                is_tap_end = True
                                break

                        if is_tap_end:
                            lane_state.state = StateType.IN_TAP_END
                        else:
                            lane_state.state = StateType.IN_START
                            if is_usable[0]:
                                lane_state.following_long_num = 1
                                is_usable[0] = False
                            elif is_usable[1]:
                                lane_state.following_long_num = 2
                                is_usable[1] = False
                            else:
                                print("セマフォが0です")
                                tstr = "追跡状況:"
                                for i in range(0, self.LANE_NUM):
                                    tstr += str(self.states[i].
                                                following_long_num) + ", "
                                print(tstr)
                                print("座標(y,x):" + str(
                                    int(lane_start_point.y) - pixel_offset) +
                                      ", " + str(lane_start_point.x))
                                print("レーン, 小節:" + str(lane_index + 1) + ", " +
                                      str(bar))
                                sys.exit("エラー終了")

                    elif lane_state.state == StateType.IN_TAP:

                        if Pixel.is_tap_frame(b, g, r):
                            note_pixel_index = (
                                lane_state.from_pixel_index + pixel_offset +
                                (bar - 1) * self.BAR_LENGTH) / 2
                            pos = note_pixel_index * 4 / self.BAR_LENGTH
                            # pixel_from_this_bar =
                            # pos_from_this_bar: float = pixel_from_this_bar / cls.BAR_LENGTH * 4.0
                            # pos = pos_from_this_bar + (bar - 1) * 4.0
                            notes[lane_index].append(
                                Note(NoteType.TAP, pos, lane_index))
                            # if bar == 6:
                            #     print("Tap@レーン, 小節:" + str(lane_index + 1) + ", " + str(bar))
                            #     print(pos)

                            lane_state.state = StateType.NONE
                            lane_state.from_pixel_index = pixel_offset

                    elif lane_state.state == StateType.IN_START:

                        if Pixel.is_green(b, g, r):
                            # pixel_from_this_bar = (lane_state.from_pixel_index + pixel_offset + (
                            #             bar - 1) * cls.BAR_LENGTH) / 2
                            # pos_from_this_bar: float = pixel_from_this_bar / cls.BAR_LENGTH * 4.0
                            # pos = pos_from_this_bar + (bar - 1) * 4.0
                            note_pixel_index = (
                                lane_state.from_pixel_index + pixel_offset +
                                (bar - 1) * self.BAR_LENGTH) / 2
                            pos = note_pixel_index * 4 / self.BAR_LENGTH

                            if lane_state.following_long_num == 1:
                                notes[lane_index].append(
                                    Note(NoteType.START, pos, lane_index))
                            elif lane_state.following_long_num == 2:
                                notes[lane_index].append(
                                    Note(NoteType.START2, pos, lane_index))
                            else:
                                print("following_long_numが不正です.@start:" +
                                      str(lane_state.following_long_num))
                                print("座標(y,x):" + str(
                                    int(lane_start_point.y) - pixel_offset) +
                                      ", " + str(lane_start_point.x))
                                print("レーン, 小節:" + str(lane_index + 1) + ", " +
                                      str(bar))
                                sys.exit("エラー終了")

                            # print("Start@レーン, 小節:" + str(lane_index + 1) + ", " + str(bar))
                            lane_state.state = StateType.NONE
                            lane_state.from_pixel_index = pixel_offset

                    elif lane_state.state == StateType.IN_TAP_END:

                        if Pixel.is_green(b, g, r):
                            # pixel_from_this_bar = (lane_state.from_pixel_index + pixel_offset + (
                            #         bar - 1) * cls.BAR_LENGTH) / 2
                            # pos_from_this_bar: float = pixel_from_this_bar / cls.BAR_LENGTH * 4.0
                            # pos = pos_from_this_bar + (bar - 1) * 4.0
                            note_pixel_index = (
                                lane_state.from_pixel_index + pixel_offset +
                                (bar - 1) * self.BAR_LENGTH) / 2
                            pos = note_pixel_index * 4 / self.BAR_LENGTH

                            if lane_state.following_long_num == 1:
                                notes[lane_index].append(
                                    Note(NoteType.TAP_END, pos, lane_index))
                                is_usable[0] = True
                            elif lane_state.following_long_num == 2:
                                notes[lane_index].append(
                                    Note(NoteType.TAP_END2, pos, lane_index))
                                is_usable[1] = True
                            else:
                                print("following_long_numが不正です.@tapEnd:" +
                                      str(lane_state.following_long_num))
                                print("座標(y,x):" + str(
                                    int(lane_start_point.y) - pixel_offset) +
                                      ", " + str(lane_start_point.x))
                                print("レーン, 小節:" + str(lane_index + 1) + ", " +
                                      str(bar))
                                sys.exit("エラー終了")

                            lane_state.state = StateType.NONE
                            lane_state.from_pixel_index = pixel_offset
                            lane_state.following_long_num = 0
                            lane_state.followable_direction = FollowableDirection.BOTH

                    elif lane_state.state == StateType.IN_FLICK:

                        if Pixel.is_flick_frame(b, g, r):
                            # pixel_from_this_bar = (lane_state.from_pixel_index + pixel_offset + (
                            #         bar - 1) * cls.BAR_LENGTH) / 2
                            # pos_from_this_bar: float = pixel_from_this_bar / cls.BAR_LENGTH * 4.0
                            # pos = pos_from_this_bar + (bar - 1) * 4.0
                            note_pixel_index = (
                                lane_state.from_pixel_index + pixel_offset +
                                (bar - 1) * self.BAR_LENGTH) / 2
                            pos = note_pixel_index * 4 / self.BAR_LENGTH
                            notes[lane_index].append(
                                Note(NoteType.FLICK, pos, lane_index))

                            # print("Flick@レーン, 小節:" + str(lane_index + 1) + ", " + str(bar))
                            lane_state.state = StateType.NONE
                            lane_state.from_pixel_index = pixel_offset

                    elif lane_state.state == StateType.IN_FLICK_END:

                        if Pixel.is_flick_frame(b, g, r):
                            # pixel_from_this_bar = (lane_state.from_pixel_index + pixel_offset + (
                            #         bar - 1) * cls.BAR_LENGTH) / 2
                            # pos_from_this_bar: float = pixel_from_this_bar / cls.BAR_LENGTH * 4.0
                            # pos = pos_from_this_bar + (bar - 1) * 4.0
                            note_pixel_index = (
                                lane_state.from_pixel_index + pixel_offset +
                                (bar - 1) * self.BAR_LENGTH) / 2
                            pos = note_pixel_index * 4 / self.BAR_LENGTH

                            if lane_state.following_long_num == 1:
                                notes[lane_index].append(
                                    Note(NoteType.FLICK_END, pos, lane_index))
                                is_usable[0] = True
                            elif lane_state.following_long_num == 2:
                                notes[lane_index].append(
                                    Note(NoteType.FLICK_END2, pos, lane_index))
                                is_usable[1] = True
                            else:
                                print("following_long_numが不正です.@flickEnd:" +
                                      str(lane_state.following_long_num))
                                print("座標(y,x):" + str(
                                    int(lane_start_point.y) - pixel_offset) +
                                      ", " + str(lane_start_point.x))
                                print("レーン, 小節:" + str(lane_index + 1) + ", " +
                                      str(bar))
                                sys.exit("エラー終了")

                            # print("FlickEnd@レーン, 小節:" + str(lane_index + 1) + ", " + str(bar))
                            lane_state.state = StateType.NONE
                            lane_state.from_pixel_index = pixel_offset
                            lane_state.following_long_num = 0
                            lane_state.followable_direction = FollowableDirection.BOTH

                    elif lane_state.state == StateType.IN_MIDDLE:

                        if Pixel.is_middle_frame(b, g, r):

                            note_pixel_index = (
                                lane_state.from_pixel_index + pixel_offset +
                                (bar - 1) * self.BAR_LENGTH) / 2
                            pos = note_pixel_index * 4 / self.BAR_LENGTH

                            if lane_state.following_long_num == 1:
                                notes[lane_index].append(
                                    Note(NoteType.MIDDLE, pos, lane_index))
                            elif lane_state.following_long_num == 2:
                                notes[lane_index].append(
                                    Note(NoteType.MIDDLE2, pos, lane_index))
                            else:
                                # 画像が間違っているので緊急措置
                                # if is_usable[0]:
                                #     lane_state.following_long_num = 1
                                #     is_usable[0] = False
                                #     notes[lane_index].append(Note(NoteType.START, pos, lane_index))
                                # elif is_usable[1]:
                                #     lane_state.following_long_num = 2
                                #     is_usable[1] = False
                                #     notes[lane_index].append(Note(NoteType.START2, pos, lane_index))
                                # else:
                                #     print("セマフォが0です")
                                #     tstr = "追跡状況:"
                                #     for i in range(0, self.LANE_NUM):
                                #         tstr += str(self.states[i].following_long_num) + ", "
                                #     print(tstr)
                                #     print("座標(y,x):" + str(int(lane_start_point.y) - pixel_offset) + ", " + str(
                                #         lane_start_point.x))
                                #     print("レーン, 小節:" + str(lane_index + 1) + ", " + str(bar))
                                #     sys.exit("エラー終了")

                                # 緊急措置による退避
                                print("following_long_numが不正です.@middle:" +
                                      str(lane_state.following_long_num))
                                print("座標(y,x):" + str(
                                    int(lane_start_point.y) - pixel_offset) +
                                      ", " + str(lane_start_point.x))
                                print("レーン, 小節:" + str(lane_index + 1) + ", " +
                                      str(bar))

                                tstr = "following_long_num: "
                                for t in self.states:
                                    tstr += str(t.following_long_num) + ", "
                                print(tstr)
                                sys.exit("エラー終了")
                                print("@lane_index:" + str(lane_index))

                            # print("Middle@レーン, 小節:" + str(lane_index + 1) + ", " + str(bar))
                            lane_state.state = StateType.NONE
                            lane_state.from_pixel_index = pixel_offset
                            lane_state.followable_direction = FollowableDirection.BOTH

                    elif lane_state.state == StateType.IN_YELLOW:
                        if Pixel.is_yellow_frame(b, g, r):
                            note_pixel_index = (
                                lane_state.from_pixel_index + pixel_offset +
                                (bar - 1) * self.BAR_LENGTH) / 2
                            pos = note_pixel_index * 4 / self.BAR_LENGTH

                            is_tap = True
                            for pixel_x in range(
                                    int(lane_start_point.x -
                                        self.LANE_WIDTH / 2),
                                    int(lane_start_point.x +
                                        self.LANE_WIDTH / 2)):

                                bgr_t = img[int(lane_start_point.y) -
                                            pixel_offset,
                                            int(pixel_x)]
                                b_t = bgr_t[0]
                                g_t = bgr_t[1]
                                r_t = bgr_t[2]
                                if Pixel.is_connecting_green(b_t, g_t, r_t):
                                    is_tap = False

                            if is_tap:
                                notes[lane_index].append(
                                    Note(NoteType.TAP, pos, lane_index))
                            else:
                                if is_usable[1]:
                                    notes[lane_index].append(
                                        Note(NoteType.START2, pos, lane_index))
                                    lane_state.following_long_num = 2
                                    is_usable[1] = False

                                elif is_usable[0]:
                                    notes[lane_index].append(
                                        Note(NoteType.START, pos, lane_index))
                                    lane_state.following_long_num = 1
                                    is_usable[0] = False

                                else:
                                    print("セマフォが0です")
                                    tstr = "追跡状況:"
                                    for i in range(0, self.LANE_NUM):
                                        tstr += str(states[i].
                                                    following_long_num) + ", "
                                    print(tstr)
                                    print("座標(y,x):" + str(
                                        int(lane_start_point.y) -
                                        pixel_offset) + ", " +
                                          str(lane_start_point.x))
                                    print("レーン, 小節:" + str(lane_index + 1) +
                                          ", " + str(bar))
                                    sys.exit("エラー終了")

                            # pixel_from_this_bar =
                            # pos_from_this_bar: float = pixel_from_this_bar / cls.BAR_LENGTH * 4.0
                            # pos = pos_from_this_bar + (bar - 1) * 4.0

                            lane_state.state = StateType.NONE
                            lane_state.from_pixel_index = pixel_offset

                    # 辿っている長押しのレーン変更を識別する
                    if lane_state.will_stop_following and lane_state.state == StateType.NONE:
                        lane_state.following_long_num = 0
                        lane_state.will_stop_following = False

                    if lane_state.following_long_num > 0 and not lane_state.will_stop_following:
                        if lane_state.state == StateType.NONE or lane_state.state == StateType.IN_START:
                            if lane_state.left_state == SubStateType.FOLLOWING_LONG:
                                if not Pixel.is_following_color(lb, lg, lr):
                                    if lane_state.followable_direction != FollowableDirection.TO_LEFT:
                                        if lane_state.right_state == SubStateType.FOLLOWING_LONG and not Pixel.is_following_color(
                                                rb, rg, rr):

                                            # 完全に真横からスタートする場合あり。ひとつ戻ってノーツの真横の色を見る
                                            bgr_br = img[
                                                int(lane_start_point.y) -
                                                pixel_offset + 1,
                                                int(lane_start_point.x) + 7]
                                            b_br = bgr_br[0]
                                            g_br = bgr_br[1]
                                            r_br = bgr_br[2]
                                            bgr_bl = img[
                                                int(lane_start_point.y) -
                                                pixel_offset + 1,
                                                int(lane_start_point.x) - 7]
                                            b_bl = bgr_bl[0]
                                            g_bl = bgr_bl[1]
                                            r_bl = bgr_bl[2]

                                            if Pixel.is_following_color(
                                                    b_br, g_br, r_br
                                            ) and Pixel.is_following_color(
                                                    b_bl, g_bl, r_bl):
                                                print("両方!?")
                                                print("座標(y,x):" + str(
                                                    int(lane_start_point.y) -
                                                    pixel_offset) + ", " +
                                                      str(lane_start_point.x))
                                                print("レーン: " +
                                                      str(lane_index + 1) +
                                                      ", 小節: " + str(bar))
                                                sys.exit("エラー終了")

                                            elif Pixel.is_following_color(
                                                    b_br, g_br, r_br):

                                                if not self.go_to_right(
                                                        lane_index):
                                                    tstr = "追跡状況:"
                                                    for i in range(
                                                            0, self.LANE_NUM):
                                                        tstr += str(
                                                            self.states[i].
                                                            following_long_num
                                                        ) + ", "
                                                    print(tstr)
                                                    print("座標(y,x):" + str(
                                                        int(lane_start_point.y)
                                                        - pixel_offset) +
                                                          ", " +
                                                          str(lane_start_point.
                                                              x))
                                                    print("レーン, 小節:" +
                                                          str(lane_index + 1) +
                                                          ", " + str(bar))
                                                    sys.exit("エラー終了")

                                            elif Pixel.is_following_color(
                                                    b_bl, g_bl, r_bl):

                                                if not self.go_to_left(
                                                        lane_index):
                                                    tstr = "追跡状況:"
                                                    for i in range(
                                                            0, self.LANE_NUM):
                                                        tstr += str(
                                                            self.states[i].
                                                            following_long_num
                                                        ) + ", "
                                                    print(tstr)
                                                    print("座標(y,x):" + str(
                                                        int(lane_start_point.y)
                                                        - pixel_offset) +
                                                          ", " +
                                                          str(lane_start_point.
                                                              x))
                                                    print("レーン, 小節:" +
                                                          str(lane_index + 1) +
                                                          ", " + str(bar))
                                                    sys.exit("エラー終了")

                                            else:
                                                print("左右ともに見つからない!?")
                                                print("座標(y,x):" + str(
                                                    int(lane_start_point.y) -
                                                    pixel_offset) + ", " +
                                                      str(lane_start_point.x))
                                                print("レーン: " +
                                                      str(lane_index + 1) +
                                                      ", 小節: " + str(bar))
                                                sys.exit("エラー終了")

                                        else:
                                            # print("@laneIndex:" + str(lane_index) + ", @bar:" + str(bar))
                                            # print("@x:" + str(lane_start_point.x) + ", @y:" + str(lane_start_point.y - pixel_offset))
                                            # print("state:" + str(lane_state.state))
                                            # if bar == 6:
                                            #     print("右(" + str(lane_index+1) + "→" + str(lane_index+2))
                                            # print("座標(y,x):" + str(int(lane_start_point.y) - pixel_offset) + ", " + str(
                                            #     lane_start_point.x))
                                            if not self.go_to_right(
                                                    lane_index):
                                                tstr = "追跡状況:"
                                                for i in range(
                                                        0, self.LANE_NUM):
                                                    tstr += str(
                                                        self.states[i].
                                                        following_long_num
                                                    ) + ", "
                                                print(tstr)
                                                print("座標(y,x):" + str(
                                                    int(lane_start_point.y) -
                                                    pixel_offset) + ", " +
                                                      str(lane_start_point.x))
                                                print("レーン, 小節:" +
                                                      str(lane_index + 1) +
                                                      ", " + str(bar))
                                                sys.exit("エラー終了")

                            if lane_state.right_state == SubStateType.FOLLOWING_LONG:
                                if not Pixel.is_following_color(rb, rg, rr):
                                    if lane_state.followable_direction != FollowableDirection.TO_RIGHT:
                                        # print(lane_index)
                                        # if bar == 6:
                                        #     print("左(" + str(lane_index+1) + "→" + str(lane_index))
                                        #     print(lane_state.followable_direction)
                                        #     print("座標(y,x):" + str(int(lane_start_point.y) - pixel_offset) + ", " + str(
                                        #     lane_start_point.x))
                                        if not self.go_to_left(lane_index):
                                            tstr = "追跡状況:"
                                            for i in range(0, self.LANE_NUM):
                                                tstr += str(
                                                    self.states[i].
                                                    following_long_num) + ", "
                                            print(tstr)
                                            print("座標(y,x):" + str(
                                                int(lane_start_point.y) -
                                                pixel_offset) + ", " +
                                                  str(lane_start_point.x))
                                            print("レーン, 小節:" +
                                                  str(lane_index + 1) + ", " +
                                                  str(bar))
                                            sys.exit("エラー終了")

                    if Pixel.is_following_color(lb, lg, lr):
                        lane_state.left_state = SubStateType.FOLLOWING_LONG
                    else:
                        lane_state.left_state = SubStateType.NONE

                    if Pixel.is_following_color(rb, rg, rr):
                        lane_state.right_state = SubStateType.FOLLOWING_LONG
                    else:
                        lane_state.right_state = SubStateType.NONE

        #
        # ------- ファイル作成 -------
        #

        bms_factory.write_main(notes)
Esempio n. 34
0
def getColorWrapAround():
    return Pixel.getWrapLevels()
Esempio n. 35
0
    def __sub__(self, other):
        r = self.getRed() - other.getRed()
        g = self.getGreen() - other.getGreen()
        b = self.getBlue() - other.getBlue()

        return Color(Pixel.correctLevel(r), Pixel.correctLevel(g), Pixel.correctLevel(b))
Esempio n. 36
0
 def setRGB(self, r, g, b):
     self.color = awt.Color(Pixel.correctLevel(r), Pixel.correctLevel(g), Pixel.correctLevel(b))
Esempio n. 37
0
def setGreen(pixel, value):
    value = Pixel.correctLevel(value)
    if not isinstance(pixel, Pixel):
        print "setGreen(pixel,value): Input is not a pixel"
        raise ValueError
    pixel.setGreen(value)
Esempio n. 38
0
    def __init__(self, pixelList, name):
        '''
        Adds a list of pixels to the Kernel object, as well as calculating statistics
        TEST ALL OF THIS
        '''
        self.name = ''
        self.pixelList = []
        self.numberOfPixels = 0
        self.RgbDict = {"Mean": '', "Mode": '', "2SDmean": ''}
        self.LabDict = {
            "LMean": '',
            "LMode": '',
            "L2SDMean": '',
            "LSD": '',
            "aMean": '',
            "aMode": '',
            "a2SDMean": '',
            "aSD": '',
            "bMean": '',
            "bMode": '',
            "b2SDMean": '',
            "bSD": ''
        }
        self.centers = []
        self.pointsPerCluster0 = 0
        self.pointsPerCluster1 = 0
        self.plot = 0
        self.name = name
        LList = []
        aList = []
        bList = []
        frequencyDict = {}
        self.pixelList = pixelList
        self.numberOfPixels = len(self.pixelList)
        for pixel in self.pixelList:
            LList.append(pixel.L)
            aList.append(pixel.A)
            bList.append(pixel.B)

            color = "r%s,g%s,b%s" % (pixel.red, pixel.green, pixel.blue)
            if color in frequencyDict.keys():
                frequencyDict[color] += 1
            else:
                frequencyDict[color] = 1
        mode = max(frequencyDict, key=frequencyDict.get)
        self.RgbDict["Mode"] = mode
        r = float(mode[1:mode.index("g") - 1])
        g = float(mode[mode.index("g") + 1:mode.index("b") - 1])
        b = float(mode[mode.index("b") + 1:])
        lab = Pixel.RGBtoHunterLab(r, g, b)
        self.LabDict["LMode"] = lab["L"]
        self.LabDict["aMode"] = lab["A"]
        self.LabDict["bMode"] = lab["B"]
        LMeanSD = meanstdv(LList)
        aMeanSD = meanstdv(aList)
        bMeanSD = meanstdv(bList)
        LMean = float(LMeanSD[0])
        aMean = float(aMeanSD[0])
        bMean = float(bMeanSD[0])
        LSD = float(LMeanSD[1])
        aSD = float(aMeanSD[1])
        bSD = float(bMeanSD[1])
        self.LabDict["LMean"] = LMean
        self.LabDict["aMean"] = aMean
        self.LabDict["bMean"] = bMean
        self.LabDict["LSD"] = LSD
        self.LabDict["aSD"] = aSD
        self.LabDict["bSD"] = bSD
        self.RgbDict["Mean"] = HunterLabToRGB(self.LabDict["LMean"],
                                              self.LabDict["aMean"],
                                              self.LabDict["bMean"])
        L2SDSum = 0
        L2SDCount = 0
        a2SDSum = 0
        a2SDCount = 0
        b2SDSum = 0
        b2SDCount = 0
        for L in LList:
            if (L <= (LMean + (2 * LSD))) and (L >= (LMean - (2 * LSD))):
                L2SDSum += L
                L2SDCount += 1
        for a in aList:
            if (a <= (aMean + (2 * aSD))) and (a >= (aMean - (2 * aSD))):
                a2SDSum += a
                a2SDCount += 1
        for b in bList:
            if (b <= (bMean + (2 * bSD))) and (b >= (bMean - (2 * bSD))):
                b2SDSum += b
                b2SDCount += 1
        self.LabDict["L2SDMean"] = L2SDSum / L2SDCount
        self.LabDict["a2SDMean"] = a2SDSum / a2SDCount
        self.LabDict["b2SDMean"] = b2SDSum / b2SDCount
        # del self.pixelList[:]
        self.setCenters()
Esempio n. 39
0
def ingest(event,
           football,
           block_basics=None,
           daq_state=None,
           block_uuid=None):
    """Ingest protobuf object.
    
    Parameters
    ----------
    event : google protobuf Event
        Event to be read
        
    football : Cassandra football object
        Cassandra interface.
        
    Returns
    -------
    boolean
        True if sucessful, False if misfit behavior.
    """
    __debug_mode = False

    # break out members by type-category
    manifest = [{'field': f, 'value': v} for [f, v] in event.ListFields()]
    bytes = [m for m in manifest if m['field'].type == m['field'].TYPE_BYTES]
    messages = [
        m for m in manifest if m['field'].type == m['field'].TYPE_MESSAGE
    ]
    enums = [m for m in manifest if m['field'].type == m['field'].TYPE_ENUM]
    basics = [
        m for m in manifest if m['field'].type in [
            m['field'].TYPE_BOOL, m['field'].TYPE_FLOAT, m['field'].
            TYPE_DOUBLE, m['field'].TYPE_INT32, m['field'].TYPE_SINT32,
            m['field'].TYPE_UINT32, m['field'].TYPE_INT64, m['field'].
            TYPE_SINT64, m['field'].TYPE_UINT64, m['field'].TYPE_STRING
        ]
    ]
    if __debug_mode:
        print '[Event] FOUND {0} bytes, {1} messages, {2} enums and {3} basics'.format(
            len(bytes), len(messages), len(enums), len(basics))

    # enforce expected structure
    if not len(manifest) - len(bytes) - len(messages) - len(enums) - len(
            basics) == 0:
        football.add_error(
            '[Event] len(all) - len(expected) = {0} [!= 0]; '.format(
                len(manifest) - len(bytes) - len(messages) - len(enums) -
                len(basics)))
    if not len(bytes) == 0:
        football.add_error('[Event] len(bytes) = {0} [!= 0]; '.format(
            len(bytes)))
    if not len(enums) == 0:
        football.add_error('[Event] len(enums) = {0} [!= 0]; '.format(
            len(enums)))

    pixels = []
    byteblock = None
    zerobias = None
    for message in messages:
        if message['field'].name == 'pixels':
            for pixel in message['value']:
                pixels.append(Pixel.ingest(pixel, football))

        elif message['field'].name == 'byteblocks':
            #football.add_error( '[Event] too many byteblocks' )
            byteblock = ByteBlock.ingest(message['value'], football)

        elif message['field'].name == 'zero_bias':
            #football.add_error( '[Event] too many zero-bias squares' )
            zerobias = ZeroBiasSquare.ingest(message['value'], football)

        else:
            football.add_error(
                '[Event] message["field"].name = {0} [!= {{pixels, byteblocks, zero_bias}}]; '
                .format(message['field'].name))

    if not football.get_n_errors() == 0:
        return False

    # save event to Cassandra
    if not football.insert_event(basics,
                                 block_basics=block_basics,
                                 daq_state=daq_state,
                                 block_uuid=block_uuid,
                                 pixels=pixels,
                                 byteblock=byteblock,
                                 zerobias=zerobias):
        football.add_error('[Event] field name missmatch: {0}'.format(
            [b['field'].name for b in basics]))

    if not football.get_n_errors() == 0:
        return False
    return True
def stick_pieces(bloc_p, bloc_e, p, e, final_stick=False):
    """
        Stick an edge of a piece to the bloc of already resolved pieces

        :param bloc_p: bloc of pieces already solved
        :param bloc_e: bloc of edges already solved
        :param p: piece to add to the bloc
        :param e: edge to stick
        :return: Nothing
    """
    f = open('./testfile.txt', 'w+')
    vec_bloc = np.subtract(bloc_e.shape[0], bloc_e.shape[-1])
    vec_piece = np.subtract(e.shape[0], e.shape[-1])

    translation = np.subtract(bloc_e.shape[0], e.shape[-1])
    angle = angle_between((vec_bloc[0], vec_bloc[1], 0),
                          (-vec_piece[0], -vec_piece[1], 0))

    # file = open('coords.txt','w+')

    # file.write(str(angle) + '\n')
    # file.close()

    # First move the first corner of piece to the corner of bloc edge
    for edge in p.edges_:
        edge.shape += translation

    # Then rotate piece of `angle` degrees centered on the corner
    for edge in p.edges_:
        for i, point in enumerate(edge.shape):
            edge.shape[i] = rotate(bloc_e.shape[0], point, -angle)

    if final_stick:
        #prev bounding box
        minX, minY, maxX, maxY = float('inf'), float(
            'inf'), -float('inf'), -float('inf')
        for i, pixel in enumerate(p.img_piece_):
            x, y = p.img_piece_[i].translate(translation[1], translation[0])
            minX, minY, maxX, maxY = min(minX,
                                         x), min(minY,
                                                 y), max(maxX,
                                                         x), max(maxY, y)
            # pixel.rotate(bloc_e.shape[0], -angle)

        #rotation center
        img_p = np.full((maxX - minX + 1, maxY - minY + 1, 3), -1)
        for pix in p.img_piece_:
            x, y = pix.pos
            x, y = x - minX, y - minY
            img_p[x, y] = pix.color

        #new bounding box
        minX2, minY2, maxX2, maxY2 = float('inf'), float(
            'inf'), -float('inf'), -float('inf')
        for x in [minX, maxX]:
            for y in [minY, maxY]:
                x2, y2 = rotate((bloc_e.shape[0][1], bloc_e.shape[0][0]),
                                (x, y), angle)
                x2, y2 = int(x2), int(y2)
                minX2, minY2, maxX2, maxY2 = min(minX2, x2), min(
                    minY2, y2), max(maxX2, x2), max(maxY2, y2)
                f.write(str(x2) + ', ' + str(y2) + '\n')

        pixels = []
        for px in range(minX2, maxX2 + 1):
            for py in range(minY2, maxY2 + 1):
                qx, qy = rotate((bloc_e.shape[0][1], bloc_e.shape[0][0]),
                                (px, py), -angle)
                qx, qy = int(qx), int(qy)
                if minX <= qx <= maxX and minY <= qy <= maxY and img_p[
                        qx - minX, qy - minY][0] != -1:
                    pixels.append(Pixel((px, py), img_p[qx - minX, qy - minY]))

        finalAng = angle * (180 / 3.14159)
        while finalAng > 360:
            finalAng = finalAng - 360
        while finalAng < 0:
            finalAng = finalAng + 360
        # print('Angle:', finalAng)

        file.write(str(finalAng) + '\n')

        p.img_piece_ = pixels