साँप के साथ एक छवि बनाएं


28

एक निरंतर 2-आयामी पथ की कल्पना करें जो केवल बाएं, दाएं मुड़ सकता है या सीधे जा सकता है, खुद को प्रतिच्छेद नहीं कर सकता है, और एक आयताकार ग्रिड को भरना चाहिए जैसे कि एक छवि में पिक्सेल का ग्रिड। हम इस तरह के रास्ते को साँप कहेंगे ।

साँप का उदाहरण

यह बढ़ा हुआ उदाहरण 10 × 4 ग्रिड में एक सांप का रास्ता दिखाता है जो लाल रंग से शुरू होता है और हर चरण में बैंगनी होने तक लगभग 2% बढ़ जाता है। (काली रेखाएँ केवल उस दिशा पर जोर देने के लिए हैं जो इसे लेती है।)

लक्ष्य

इस लोकप्रियता प्रतियोगिता में लक्ष्य एक एल्गोरिथ्म लिखना है जो एक एकल साँप का उपयोग करके किसी दिए गए चित्र को फिर से बनाने का प्रयास करता है जिसका रंग लगातार छोटी मात्रा में बदलता रहता है।

आपके कार्यक्रम को किसी भी आकार की एक सच्चे रंग की छवि के साथ-साथ 0 और 1 के बीच फ्लोटिंग पॉइंट वैल्यू, सहिष्णुता में लेना चाहिए

सहिष्णुता अधिकतम राशि को परिभाषित करती है साँप का रंग प्रत्येक पिक्सेल आकार के चरण में बदलने की अनुमति है। जब आरजीबी रंग घन पर व्यवस्थित किया जाता है, तो हम दो आरजीबी रंगों के बीच की दूरी को यूक्लिडियन दूरी के रूप में परिभाषित करेंगे । तब दूरी सामान्य हो जाएगी इसलिए अधिकतम दूरी 1 है और न्यूनतम दूरी 0 है।

रंग दूरी pseudocode: (मान लेता है कि सभी इनपुट मान श्रेणी में पूर्णांक हैं [0, 255]; आउटपुट सामान्यीकृत है।)

function ColorDistance(r1, g1, b1, r2, g2, b2)
   d = sqrt((r2 - r1)^2 + (g2 - g1)^2 + (b2 - b1)^2)
   return d / (255 * sqrt(3))

यदि सांप के वर्तमान रंग पर इस फ़ंक्शन को कॉल करने का परिणाम और एक अन्य रंग दिए गए सहिष्णुता से अधिक है, तो सांप उस दूसरे रंग में नहीं बदल सकता है।

यदि आप पसंद करते हैं, तो आप एक अलग रंग दूरी समारोह का उपयोग कर सकते हैं। यह कुछ सटीक और अच्छी तरह से प्रलेखित होना चाहिए जैसे कि http://en.wikipedia.org/wiki/Color_difference पर सूचीबद्ध । आपको इसे सामान्य रूप से भीतर होना चाहिए [0, 1], अर्थात अधिकतम संभव दूरी 1 होनी चाहिए और न्यूनतम 0. होना चाहिए। यदि आप एक अलग दूरी की मीट्रिक का उपयोग करते हैं, तो हमें अपने उत्तर में बताएं।

परीक्षण छवियाँ

आपको निश्चित रूप से अपनी आउटपुट छवियां (और यदि आप चाहते हैं तो सांप के बढ़ने के एनिमेशन) भी पोस्ट करना चाहिए। मैं विभिन्न निम्न सहिष्णुता (शायद 0.005 से 0.03 के आसपास) का उपयोग करके इन चित्रों की एक किस्म पोस्ट करने का सुझाव देता हूं।

एक प्रकार का बंदर मोना लीसा महान लहर लीना यादृच्छिक रंग, ग्रेडर misc (बड़ी लहर)

विन क्राइटेरिया

जैसा कि कहा गया है, यह एक लोकप्रियता प्रतियोगिता है। सबसे ज्यादा वोट देने वाला जवाब जीत जाएगा। इनपुट छवियों के चित्रण का सबसे सटीक और सौंदर्यवादी रूप से "साँप पथ" प्रदान करने वाले उत्तरों को वोट दिया जाना चाहिए।

कोई भी उपयोगकर्ता जो दुर्भावनापूर्ण रूप से ऐसे चित्र प्रस्तुत करता है, जो वास्तविक साँप नहीं हैं, उन्हें हमेशा के लिए अयोग्य घोषित कर दिया जाएगा।

टिप्पणियाँ

  • केवल एक साँप पथ का उपयोग किया जा सकता है और इसे दो बार एक ही पिक्सेल को छुए बिना पूरी तरह से छवि को भरना होगा।
  • साँप छवि में कहीं भी शुरू और समाप्त हो सकता है।
  • सांप किसी भी रंग के रूप में शुरू हो सकता है।
  • साँप को छवि की सीमा में रहना चाहिए। सीमा चक्रीय नहीं हैं।
  • साँप तिरछे या एक से अधिक पिक्सेल को एक बार में नहीं हिला सकता।

14
गंभीरता से, आपने १६ दिनों में १४ दिनों में कैसे एक के बाद एक बिना सैंडबॉक्सिंग के १६ दिनों में अच्छी चुनौतियां (जिनमें से अब तीसरी सबसे अच्छी है) पोस्ट करने का प्रबंधन किया? बिग कुडोस, पीपीसीजी को आपके जैसे और लोगों की जरूरत है! ;)
मार्टिन एंडर

@ मार्टिनबटनर को यकीन नहीं है। वे बस स्वाभाविक रूप से मेरे पास आते हैं :) निष्पक्ष होने के लिए एक प्रश्न जो मैंने सैंडबॉक्स किया था वह बहुत अच्छी तरह से प्राप्त नहीं हुआ था: meta.codegolf.stackexchange.com/a/1820/26997
केल्विन के

मुझे यकीन नहीं है कि मेरा समाधान एक अनंत लूप में फंस गया है, या यह वास्तव में वास्तव में लंबा समय ले रहा है। और यह केवल एक 80x80 की छवि है!
दरवाज़े

1
ओह मेरी ... यह वास्तव में मजेदार लग रहा है।
cjfaure

1
मुझे लगता है कि यह बिल्कुल मूल छवि के रूप में आवश्यक नहीं है, बस एक प्रतिकृति संभव के रूप में बंद करें।
Οurous

जवाबों:


24

अजगर

सांप के यात्रा करते ही मैं रंग परिवर्तन को कम करने के लिए एक गतिशील पथ उत्पन्न करता हूं। यहाँ कुछ चित्र दिए गए हैं:

सहनशीलता = 0.01

मोना लिसा 0.01 सहिष्णुता मैनड्रिल 0.01 सहिष्णुता

उपरोक्त छवियों के लिए चक्रीय रंग पथ (नीले से लाल, दोहराए जाने के रूप में मिल रहा है):

साइना कलर्स में मोना लिसा स्नेक पाथ चक्रीय रंगों में मैंड्रिल स्नेक पाथ

पथ कुछ प्रारंभिक पथ से शुरू करके उत्पन्न होता है, फिर छवि को भरने तक उस पर 2x2 लूप जोड़ते हैं। इस पद्धति का लाभ यह है कि छोरों को पथ पर कहीं भी जोड़ा जा सकता है, इसलिए आप अपने आप को एक कोने में पेंट नहीं कर सकते हैं और आपके द्वारा इच्छित पथ के निर्माण के लिए अधिक स्वतंत्रता है। मैं वर्तमान पथ से सटे संभावित छोरों का ट्रैक रखता हूं और उन्हें एक ढेर में संग्रहीत करता हूं, जो लूप के साथ रंग परिवर्तन से भारित होता है। मैं फिर कम से कम रंग बदलने के साथ लूप को बंद कर देता हूं और इसे पथ में जोड़ता हूं, और जब तक छवि नहीं भर जाती है तब तक दोहराएं।

मैं वास्तव में छोरों को ट्रैक करता हूं (कोड में 'डेटरब्लॉक'), फिर पथ को फिर से संगठित करें; यह एक गलती थी क्योंकि विषम चौड़ाई / ऊंचाई के लिए कुछ विशेष मामले हैं और मैंने पुनर्निर्माण पद्धति को डिबग करने में कई घंटे बिताए। ओह अच्छा।

पथ निर्माण मीट्रिक को ट्यूनिंग की आवश्यकता होती है और मुझे बेहतर रंगीकरण के लिए भी एक विचार है, लेकिन मैंने सोचा कि मैं इसे पहले निकाल लूंगा क्योंकि यह काफी अच्छी तरह से काम करता है। इस एक को छोड़कर, जो कुछ निश्चित रास्तों में बेहतर लगता है:

विविध सामग्री 0.01 सहिष्णुता

यहाँ मेरी अदम्य कोडिंग आदतों के लिए माफी के साथ पायथन कोड है:

# snakedraw.py
# Image library: Pillow
# Would like to animate with matplotlib... (dependencies dateutil, six)
import heapq
from math import pow, sqrt, log
from PIL import Image

tolerance = 0.001
imageList = [ "lena.png", "MonaLisa.png", "Mandrill.png", "smallGreatWave.png", "largeGreatWave.png", "random.png"]

# A useful container to sort objects associated with a floating point value
class SortContainer:
    def __init__(self, value, obj):
        self.fvalue = float(value)
        self.obj = obj
    def __float__(self):
        return float(self.fvalue)
    def __lt__(self, other):
        return self.fvalue < float(other)
    def __eq__(self, other):
        return self.fvalue == float(other)
    def __gt__(self, other):
        return self.fvalue > float(other)

# Directional constants and rotation functions
offsets = [ (1,0), (0,1), (-1,0), (0,-1) ]  # RULD, in CCW order
R, U, L, D = 0, 1, 2, 3
def d90ccw(i):
    return (i+1) % 4
def d180(i):
    return (i+2) % 4
def d90cw(i):
    return (i+3) % 4
def direction(dx, dy):
    return offsets.index((dx,dy))


# Standard color metric: Euclidean distance in the RGB cube. Distance between opposite corners normalized to 1.
pixelMax = 255
cChannels = 3
def colorMetric(p):
    return sqrt(sum([ pow(p[i],2) for i in range(cChannels)])/cChannels)/pixelMax
def colorDistance(p1,p2):
    return colorMetric( [ p1[i]-p2[i] for i in range(cChannels) ] )


# Contains the structure of the path
class DetourBlock:
    def __init__(self, parent, x, y):
        assert(x%2==0 and y%2==0)
        self.x = x
        self.y = y
        self.parent = None
        self.neighbors = [None, None, None, None]
    def getdir(A, B):
        dx = (B.x - A.x)//2
        dy = (B.y - A.y)//2
        return direction(dx, dy)

class ImageTracer:
    def __init__(self, imgName):

        self.imgName = imgName
        img = Image.open(imgName)
        img = img.convert(mode="RGB")       # needed for BW images
        self.srcImg = [ [ [ float(c) for c in img.getpixel( (x,y) ) ] for y in range(img.size[1]) ] for x in range(img.size[0])]
        self.srcX = img.size[0]
        self.srcY = img.size[1]

        # Set up infrastructure
        self.DetourGrid = [ [ DetourBlock(None, 2*x, 2*y) \
                    for y in range((self.srcY+1)//2)] \
                    for x in range((self.srcX+1)//2)]
        self.dgX = len(self.DetourGrid)
        self.dgY = len(self.DetourGrid[0])
        self.DetourOptions = list()    # heap!
        self.DetourStart = None
        self.initPath()

    def initPath(self):
        print("Initializing")
        if not self.srcX%2 and not self.srcY%2:
            self.AssignToPath(None, self.DetourGrid[0][0])
            self.DetourStart = self.DetourGrid[0][0]
        lastDB = None
        if self.srcX%2:     # right edge initial path
            self.DetourStart = self.DetourGrid[-1][0]
            for i in range(self.dgY):
                nextDB = self.DetourGrid[-1][i]
                self.AssignToPath(lastDB, nextDB)
                lastDB = nextDB
        if self.srcY%2:     # bottom edge initial path
            if not self.srcX%2:
                self.DetourStart = self.DetourGrid[-1][-1]
            for i in reversed(range(self.dgX-(self.srcX%2))):          # loop condition keeps the path contiguous and won't add corner again
                nextDB =  self.DetourGrid[i][-1]
                self.AssignToPath(lastDB, nextDB)
                lastDB = nextDB

    # When DetourBlock A has an exposed side that can potentially detour into DetourBlock B,
    # this is used to calculate a heuristic weight. Lower weights are better, they minimize the color distance
    # between pixels connected by the snake path
    def CostBlock(self, A, B):
        # Weight the block detour based on [connections made - connections broken]
        dx = (B.x - A.x)//2
        dy = (B.y - A.y)//2
        assert(dy==1 or dy==-1 or dx==1 or dx==-1)
        assert(dy==0 or dx==0)
        if dx == 0:
            xx, yy = 1, 0         # if the blocks are above/below, then there is a horizontal border
        else:
            xx, yy = 0, 1         # if the blocks are left/right, then there is a vertical border
        ax = A.x + (dx+1)//2
        ay = A.y + (dy+1)//2 
        bx = B.x + (1-dx)//2
        by = B.y + (1-dy)//2
        fmtImg = self.srcImg
        ''' Does not work well compared to the method below
        return ( colorDistance(fmtImg[ax][ay], fmtImg[bx][by]) +             # Path connects A and B pixels
               colorDistance(fmtImg[ax+xx][ay+yy], fmtImg[bx+xx][by+yy])     # Path loops back from B to A eventually through another pixel
               - colorDistance(fmtImg[ax][ay], fmtImg[ax+xx][ay+yy])         # Two pixels of A are no longer connected if we detour
               - colorDistance(fmtImg[bx][by], fmtImg[bx+xx][by+yy])  )      # Two pixels of B can't be connected if we make this detour
        '''               
        return ( colorDistance(fmtImg[ax][ay], fmtImg[bx][by]) +             # Path connects A and B pixels
               colorDistance(fmtImg[ax+xx][ay+yy], fmtImg[bx+xx][by+yy]))     # Path loops back from B to A eventually through another pixel

    # Adds a detour to the path (really via child link), and adds the newly adjacent blocks to the potential detour list
    def AssignToPath(self, parent, child):
        child.parent = parent
        if parent is not None:
            d = parent.getdir(child)
            parent.neighbors[d] = child
            child.neighbors[d180(d)] = parent
        for (i,j) in offsets:
            x = int(child.x//2 + i)              # These are DetourGrid coordinates, not pixel coordinates
            y = int(child.y//2 + j)
            if x < 0 or x >= self.dgX-(self.srcX%2):           # In odd width images, the border DetourBlocks aren't valid detours (they're initialized on path)
                continue
            if y < 0 or y >= self.dgY-(self.srcY%2):
                continue
            neighbor = self.DetourGrid[x][y]
            if neighbor.parent is None:
                heapq.heappush(self.DetourOptions, SortContainer(self.CostBlock(child, neighbor), (child, neighbor)) )

    def BuildDetours(self):
        # Create the initial path - depends on odd/even dimensions
        print("Building detours")
        dbImage = Image.new("RGB", (self.dgX, self.dgY), 0)
        # We already have our initial queue of detour choices. Make the best choice and repeat until the whole path is built.
        while len(self.DetourOptions) > 0:
            sc = heapq.heappop(self.DetourOptions)       # Pop the path choice with lowest cost
            parent, child = sc.obj
            if child.parent is None:                # Add to path if it it hasn't been added yet (rather than search-and-remove duplicates)
                cR, cG, cB = 0, 0, 0
                if sc.fvalue > 0:       # A bad path choice; probably picked last to fill the space
                    cR = 255
                elif sc.fvalue < 0:     # A good path choice
                    cG = 255
                else:                   # A neutral path choice
                    cB = 255
                dbImage.putpixel( (child.x//2,child.y//2), (cR, cG, cB) )
                self.AssignToPath(parent, child)
        dbImage.save("choices_" + self.imgName)

    # Reconstructing the path was a bad idea. Countless hard-to-find bugs!
    def ReconstructSnake(self):
        # Build snake from the DetourBlocks.
        print("Reconstructing path")
        self.path = []
        xi,yi,d = self.DetourStart.x, self.DetourStart.y, U   # good start? Okay as long as CCW
        x,y = xi,yi
        while True:
            self.path.append((x,y))
            db = self.DetourGrid[x//2][y//2]                     # What block do we occupy?
            if db.neighbors[d90ccw(d)] is None:                  # Is there a detour on my right? (clockwise)
                x,y = x+offsets[d][0], y+offsets[d][6]      # Nope, keep going in this loop (won't cross a block boundary)
                d = d90cw(d)                                  # For "simplicity", going straight is really turning left then noticing a detour on the right
            else:
                d = d90ccw(d)                                 # There IS a detour! Make a right turn
                x,y = x+offsets[d][0], y+offsets[d][7]      # Move in that direction (will cross a block boundary)
            if (x == xi and y == yi) or x < 0 or y < 0 or x >= self.srcX or y >= self.srcY:                         # Back to the starting point! We're done!
                break
        print("Retracing path length =", len(self.path))       # should = Width * Height

        # Trace the actual snake path
        pathImage = Image.new("RGB", (self.srcX, self.srcY), 0)
        cR, cG, cB = 0,0,128
        for (x,y) in self.path:
            if x >= self.srcX or y >= self.srcY:
                break
            if pathImage.getpixel((x,y)) != (0,0,0):
                print("LOOPBACK!", x, y)
            pathImage.putpixel( (x,y), (cR, cG, cB) )
            cR = (cR + 2) % pixelMax
            if cR == 0:
                cG = (cG + 4) % pixelMax
        pathImage.save("path_" + self.imgName)

    def ColorizeSnake(self):
        #Simple colorization of path
        traceImage = Image.new("RGB", (self.srcX, self.srcY), 0)
        print("Colorizing path")
        color = ()
        lastcolor = self.srcImg[self.path[0][0]][self.path[0][8]]
        for i in range(len(self.path)):
            v = [ self.srcImg[self.path[i][0]][self.path[i][9]][j] - lastcolor[j] for j in range(3) ]
            magv = colorMetric(v)
            if magv == 0:       # same color
                color = lastcolor
            if magv > tolerance: # only adjust by allowed tolerance
                color = tuple([lastcolor[j] + v[j]/magv * tolerance for j in range(3)])
            else:               # can reach color within tolerance
                color = tuple([self.srcImg[self.path[i][0]][self.path[i][10]][j] for j in range(3)])
            lastcolor = color
            traceImage.putpixel( (self.path[i][0], self.path[i][11]), tuple([int(color[j]) for j in range(3)]) )
        traceImage.save("snaked_" + self.imgName)


for imgName in imageList:
    it = ImageTracer(imgName)
    it.BuildDetours()
    it.ReconstructSnake()
    it.ColorizeSnake()

और 0.001 के बहुत कम सहिष्णुता पर कुछ और चित्र :

ग्रेट वेव 0.001 सहनशीलता मोना लिसा 0.001 सहिष्णुता लीना 0.001 सहिष्णुता

और यह भी महान लहर रास्ता है क्योंकि यह साफ है:

यहाँ छवि विवरण दर्ज करें

संपादित करें

जब अपने आसन्न पिक्सेल के बीच रंग की दूरी के योग को कम करने के बजाय, आसन्न ब्लॉकों के औसत रंगों के बीच रंग की दूरी को कम करते समय पथ निर्माण बेहतर लगता है। इसके अलावा, यह पता चला है कि आप किसी भी दो सहिष्णुता-अनुरूप सांप पथ के रंगों को औसत कर सकते हैं और एक और सहिष्णुता-अनुरूप सांप पथ के साथ समाप्त हो सकते हैं। इसलिए मैं दोनों तरीकों से मार्ग को पार करता हूं और उन्हें औसत करता हूं, जो बहुत सारी कलाकृतियों को चिकना करता है। ज़ोंबी लीना और डरावना हाथ मोना ज्यादा बेहतर लगते हैं। अंतिम संस्करण:

सहिष्णुता 0.01 :

अंतिम मोना 0.01 अंतिम लीना 0.01

फाइनल ग्रेट वेव 0.01

सहिष्णुता 0.001 :

अंतिम मोना अंतिम लीना

अंतिम महान लहर


4
सबसे अच्छा अभी तक! मुझे लगता है कि ग्रेट वेव कैसा दिखता है!
केल्विन के शौक

मुझे इस चुनौती का जवाब अजगर हेह में दिया गया था
अल्बर्ट रेनशॉ

17

जावा

मेरा कार्यक्रम एक दिए गए चौड़ाई और ऊंचाई के लिए एक सांप का रास्ता उत्पन्न करता है, जो कि हिल्बर्ट वक्र उत्पन्न करने वाले के समान एल्गोरिथ्म का उपयोग करता है।

यहाँ छवि विवरण दर्ज करें

(थोड़ा खेल: उपरोक्त चित्र में, साँप शीर्ष बाएँ कोने पर शुरू होता है। क्या आप पा सकते हैं कि वह कहाँ समाप्त होता है? शुभकामनाएँ :)

यहां विभिन्न सहिष्णुता मूल्यों के लिए परिणाम दिए गए हैं:

सहिष्णुता = 0.01

सहिष्णुता = 0.01

सहिष्णुता = ०.०५

सहिष्णुता = 0.05

सहिष्णुता = 0.1

सहिष्णुता = 0.01

सहिष्णुता = 0.01

लहर

4x4 पिक्सेल ब्लॉक और दिखाई देने वाले पथ के साथ

यहाँ छवि विवरण दर्ज करें

साँप के पथ का अभिकलन करना

एक साँप पथ एक दोहरे आयाम पूर्णांक सरणी में संग्रहीत होता है। साँप हमेशा ऊपरी बाएँ कोने से ग्रिड में प्रवेश करता है। 4 बुनियादी ऑपरेशन मेरे कार्यक्रम एक दिए गए साँप पथ पर कर सकते हैं:

  • चौड़ाई 1 या ऊँचाई के ग्रिड के लिए एक नया साँप पथ बनाएँ। पथ केवल एक सरल रेखा है जो मामले के आधार पर दाईं या बाईं ओर नीचे जाती है।

  • ग्रिड की ऊँचाई बढ़ाएँ, ऊपर से बाएँ से दाएँ एक साँप पथ को जोड़कर, फिर ग्रिड को प्रतिबिंबित करके (साँप को हमेशा ऊपरी बाएँ कोने से ग्रिड में प्रवेश करना चाहिए)

  • ग्रिड की चौड़ाई बढ़ाएँ, ऊपर से नीचे तक एक साँप के रास्ते को जोड़कर, फिर ग्रिड को फ़्लिप करके (ऊपरी बाएँ कोने से साँप को हमेशा ग्रिड में प्रवेश करना चाहिए)

  • एक "हिल्बर्ट शैली" एल्गोरिथ्म का उपयोग करके ग्रिड के आयाम को दोगुना करें (नीचे विवरण देखें)

इन परमाणु परिचालनों की एक श्रृंखला का उपयोग करके, कार्यक्रम किसी भी दिए गए आकार का एक साँप पथ उत्पन्न करने में सक्षम है।

नीचे दिए गए कोड (रिवर्स ऑर्डर में) को दिए गए चौड़ाई और ऊंचाई प्राप्त करने के लिए कौन से संचालन की आवश्यकता होगी। एक बार गणना करने के बाद, क्रियाओं को एक-एक करके निष्पादित किया जाता है जब तक कि हमें अपेक्षित आकार का एक साँप पथ नहीं मिला।

enum Action { ADD_LINE_TOP, ADD_LINE_LEFT, DOUBLE_SIZE, CREATE};

public static int [][] build(int width, int height) {
    List<Action> actions = new ArrayList<Action>();
    while (height>1 && width>1) {
        if (height % 2 == 1) {
            height--;
            actions.add(Action.ADD_LINE_TOP);
        }
        if (width % 2 == 1) {
            width--;                
            actions.add(Action.ADD_LINE_LEFT);
        }
        if (height%2 == 0 && width%2 == 0) {
            actions.add(Action.DOUBLE_SIZE);
            height /= 2;
            width /= 2;
        }
    }
    actions.add(Action.CREATE);
    Collections.reverse(actions);
    int [][] tab = null;
    for (Action action : actions) {
        // do the stuff
    }

सांप के रास्ते का आकार दोगुना करना:

एल्गोरिथ्म जो आकार को दोगुना करता है वह निम्नानुसार काम करता है:

इस नोड पर विचार करें जो RIGHT और BOTTOM से जुड़ा हुआ है। मैं इसका आकार दोगुना करना चाहता हूं।

 +-
 |

इसके आकार को दोगुना करने और समान निकास (दाएं और नीचे) रखने के 2 तरीके हैं:

 +-+- 
 |
 +-+
   |

या

+-+
| |
+ +-
|

यह निर्धारित करने के लिए कि किसे चुनना है, मुझे प्रत्येक नोड दिशा "शिफ्ट" मान के लिए संभालना होगा, यह दर्शाता है कि निकास द्वार को बाएं / दाएं या ऊपर / नीचे स्थानांतरित किया गया है। मैं पथ का अनुसरण करता हूं जैसे कि सांप करता है, और पथ के साथ शिफ्ट मान को अपडेट करता है। शिफ्ट मान विशिष्ट रूप से निर्धारित करता है कि अगले चरण के लिए मुझे किस ब्लॉक का उपयोग करना है।


3
हिल्बर्ट वक्र के लिए +1। यह इस के साथ बहुत स्वाभाविक लगता है, लेकिन अगर आप अपना कोड पोस्ट कर सकते हैं तो यह अच्छा होगा।
izlin

@izlin बहुत कोड है - मैं कुछ भागों को पोस्ट करने की कोशिश करूंगा
अरनौद

1
@SuperChafouin यदि यह 30k अक्षर से कम का है, तो कृपया इसे पोस्ट करें। SE अपने आप एक स्क्रॉलबार जोड़ देगा।
मार्टिन एंडर

थोड़ा जल्दी और गंदा है कि मेरा कोड फिर से काम करेंगे और इसे :-)
Arnaud

3
मैं हार गया, यह कहाँ समाप्त होता है ?!
टीएमएच

10

अजगर

यहां चीजें शुरू करने के लिए एक बहुत ही सरल एल्गोरिथ्म है। यह छवि के ऊपर बाईं ओर शुरू होता है और अंदर की ओर सर्पिल होता है, जो सहनशीलता के भीतर रहते हुए रंग को अगले पिक्सेल के रंग के जितना करीब संभव बनाता है।

import Image

def colorDist(c1, c2): #not normalized
    return (sum((c2[i] - c1[i])**2 for i in range(3)))**0.5

def closestColor(current, goal, tolerance):
    tolerance *= 255 * 3**0.5
    d = colorDist(current, goal)
    if d > tolerance: #return closest color in range
        #due to float rounding this may be slightly outside of tolerance range
        return tuple(int(current[i] + tolerance * (goal[i] - current[i]) / d) for i in range(3))
    else:
        return goal

imgName = 'lena.png'
tolerance = 0.03

print 'Starting %s at %.03f tolerance.' % (imgName, tolerance)

img = Image.open(imgName).convert('RGB')

imgData = img.load()
out = Image.new('RGB', img.size)
outData = out.load()

x = y = 0
c = imgData[x, y]
traversed = []
state = 'right'

updateStep = 1000

while len(traversed) < img.size[0] * img.size[1]:
    if len(traversed) > updateStep and len(traversed) % updateStep == 0:
        print '%.02f%% complete' % (100 * len(traversed) / float(img.size[0] * img.size[1]))
    outData[x, y] = c
    traversed.append((x, y))
    oldX, oldY = x, y
    oldState = state
    if state == 'right':
        if x + 1 >= img.size[0] or (x + 1, y) in traversed:
            state = 'down'
            y += 1
        else:
            x += 1
    elif state == 'down':
        if y + 1 >= img.size[1] or (x, y + 1) in traversed:
            state = 'left'
            x -= 1
        else:
            y += 1
    elif state == 'left':
        if x - 1 < 0 or (x - 1, y) in traversed:
            state = 'up'
            y -= 1
        else:
            x -= 1
    elif state == 'up':
        if y - 1 < 0 or (x, y - 1) in traversed:
            state = 'right'
            x += 1
        else:
             y -= 1
    c = closestColor(c, imgData[x, y], tolerance)

out.save('%.03f%s' % (tolerance, imgName))
print '100% complete'

बड़ी छवियों को चलाने में एक या दो मिनट लगते हैं, हालांकि मुझे यकीन है कि स्पाइरलिंग तर्क को काफी हद तक अनुकूलित किया जा सकता है।

परिणाम

वे दिलचस्प हैं, लेकिन भव्य नहीं हैं। आश्चर्यजनक रूप से 0.1 से ऊपर की सहिष्णुता काफी सटीक दिखने वाले परिणाम पैदा करती है।

0.03 सहिष्णुता पर महान लहर:

0.03 सहिष्णुता पर महान लहर

0.02 सहिष्णुता पर मोना लिसा:

मोना लिसा 0.02 सहिष्णुता पर

लीना 0.03 सहिष्णुता पर, फिर 0.01, फिर 0.005, फिर 0.003:

लीना 0.03 सहिष्णुता पर 0.01 सहिष्णुता पर लीना 0.005 सहिष्णुता पर लीना [0.003 सहिष्णुता पर लीना

0.1 सहिष्णुता पर सामान मिलता है, फिर 0.07, फिर 0.04, फिर 0.01:

0.1 सहिष्णुता पर विविध सामान 0.07 सहिष्णुता पर विविध सामान 0.04 सहिष्णुता पर विविध सामान 0.01 सहिष्णुता पर विविध सामान


13
अजगर के साथ एक साँप कार्यक्रम लिखने के लिए वैध लगता है।
अरनौद

10

कोबरा

@number float
use System.Drawing
class Program
    var source as Bitmap?
    var data as List<of uint8[]> = List<of uint8[]>()
    var canvas as List<of uint8[]> = List<of uint8[]>()
    var moves as int[] = @[0,1]
    var direction as bool = true
    var position as int[] = int[](0)
    var tolerance as float = 0f
    var color as uint8[] = uint8[](4)
    var rotated as bool = false
    var progress as int = 0
    def main
        args = CobraCore.commandLineArgs
        if args.count <> 3, throw Exception()
        .tolerance = float.parse(args[1])
        if .tolerance < 0 or .tolerance > 1, throw Exception()
        .source = Bitmap(args[2])
        .data = .toData(.source to !)
        .canvas = List<of uint8[]>()
        average = float[](4)
        for i in .data
            .canvas.add(uint8[](4))
            for n in 4, average[n] += i[n]/.source.height
        for n in 4, .color[n] = (average[n]/.source.width).round to uint8
        if .source.width % 2
            if .source.height % 2
                .position = @[0, .source.height-1]
                .update
                while .position[1] > 0, .up
                .right
            else
                .position = @[.source.width-1, .source.height-1]
                .update
                while .position[1] > 0, .up
                while .position[0] > 0, .left
                .down
        else
            if .source.height % 2
                .position = @[0,0]
                .update
            else
                .position = @[.source.width-1,0]
                .update
                while .position[0] > 0, .left
                .down
        .right
        .down
        while true
            if (1-.source.height%2)<.position[1]<.source.height-1
                if .moves[1]%2==0
                    if .direction, .down
                    else, .up
                else
                    if .moves[0]==2, .right
                    else, .left
            else
                .right
                if .progress == .data.count, break
                .right
                .right
                if .direction
                    .direction = false
                    .up
                else
                    .direction = true
                    .down
        image = .toBitmap(.canvas, .source.width, .source.height)
        if .rotated, image.rotateFlip(RotateFlipType.Rotate270FlipNone)
        image.save(args[2].split('.')[0]+'_snake.png')

    def right
        .position[0] += 1
        .moves = @[.moves[1], 0]
        .update

    def left
        .position[0] -= 1
        .moves = @[.moves[1], 2]
        .update

    def down
        .position[1] += 1
        .moves = @[.moves[1], 1]
        .update

    def up
        .position[1] -= 1
        .moves = @[.moves[1], 3]
        .update

    def update
        .progress += 1
        index = .position[0]+.position[1]*(.source.width)
        .canvas[index] = .closest(.color,.data[index])
        .color = .canvas[index]

    def closest(color1 as uint8[], color2 as uint8[]) as uint8[]
        d = .difference(color1, color2)
        if d > .tolerance
            output = uint8[](4)
            for i in 4, output[i] = (color1[i] + .tolerance * (color2[i] - _
            color1[i]) / d)to uint8
            return output
        else, return color2

    def difference(color1 as uint8[], color2 as uint8[]) as float
        d = ((color2[0]-color1[0])*(color2[0]-color1[0])+(color2[1]- _
        color1[1])*(color2[1]-color1[1])+(color2[2]-color1[2])*(color2[2]- _
        color1[2])+0f).sqrt
        return d / (255 * 3f.sqrt)

    def toData(image as Bitmap) as List<of uint8[]>
        rectangle = Rectangle(0, 0, image.width, image.height)
        data = image.lockBits(rectangle, System.Drawing.Imaging.ImageLockMode.ReadOnly, _
        image.pixelFormat) to !
        ptr = data.scan0
        bytes = uint8[](data.stride*image.height)
        System.Runtime.InteropServices.Marshal.copy(ptr, bytes, 0, _
        data.stride*image.height)
        pfs = Image.getPixelFormatSize(data.pixelFormat)//8
        pixels = List<of uint8[]>()
        for y in image.height, for x in image.width
            position = (y * data.stride) + (x * pfs)
            red, green, blue, alpha = bytes[position+2], bytes[position+1], _
            bytes[position], if(pfs==4, bytes[position+3], 255u8)
            pixels.add(@[red, green, blue, alpha])
        image.unlockBits(data)
        return pixels

    def toBitmap(pixels as List<of uint8[]>, width as int, height as int) as Bitmap
        image = Bitmap(width, height, Imaging.PixelFormat.Format32bppArgb)
        rectangle = Rectangle(0, 0, image.width, image.height)
        data = image.lockBits(rectangle, System.Drawing.Imaging.ImageLockMode.ReadWrite, _
        image.pixelFormat) to !
        ptr = data.scan0
        bytes = uint8[](data.stride*image.height)
        pfs = System.Drawing.Image.getPixelFormatSize(image.pixelFormat)//8
        System.Runtime.InteropServices.Marshal.copy(ptr, bytes, 0, _
        data.stride*image.height)
        count = -1
        for y in image.height, for x in image.width 
            pos = (y*data.stride)+(x*pfs)
            bytes[pos+2], bytes[pos+1], bytes[pos], bytes[pos+3] = pixels[count+=1]
        System.Runtime.InteropServices.Marshal.copy(bytes, 0, ptr, _
        data.stride*image.height)
        image.unlockBits(data)
        return image

एक सांप के साथ छवि को भरता है जैसे:

#--#
   |
#--#
|
#--#
   |

यह वैकल्पिक दिशाओं में सिर्फ पंक्तियों की तुलना में बहुत तेज रंग समायोजन की अनुमति देता है, लेकिन 3-वाइड संस्करण के रूप में अवरुद्ध नहीं होता है।

बहुत कम सहिष्णुता पर भी, एक छवि के किनारे अभी भी दिखाई दे रहे हैं (हालांकि छोटे प्रस्तावों में विस्तार के नुकसान पर)।

0.01

यहाँ छवि विवरण दर्ज करें

0.1

यहाँ छवि विवरण दर्ज करें

0.01

यहाँ छवि विवरण दर्ज करें

0.01

यहाँ छवि विवरण दर्ज करें

0.1

यहाँ छवि विवरण दर्ज करें

0.03

यहाँ छवि विवरण दर्ज करें

0.005

यहाँ छवि विवरण दर्ज करें


1

सी#

साँप शीर्ष सफेद रंग के साथ बाएँ पिक्सेल पर शुरू होता है और बाईं ओर दाईं ओर और फिर बाईं ओर दाईं ओर छवि को छोड़ता है।

using System;
using System.Drawing;

namespace snake
{
    class Snake
    {
        static void MakeSnake(Image original, double tolerance)
        {
            Color snakeColor = Color.FromArgb(255, 255, 255);//start white
            Bitmap bmp = (Bitmap)original;
            int w = bmp.Width;
            int h = bmp.Height;
            Bitmap snake = new Bitmap(w, h);

            //even rows snake run left to right else run right to left
            for (int y = 0; y < h; y++)
            {
                if (y % 2 == 0)
                {
                    for (int x = 0; x < w; x++)//L to R
                    {
                        Color pix = bmp.GetPixel(x, y);
                        double diff = Snake.RGB_Distance(snakeColor, pix);
                        if (diff < tolerance)
                        {
                            snakeColor = pix;
                        }
                        //else keep current color
                        snake.SetPixel(x, y, snakeColor);
                    }
                }
                else
                {
                    for (int x = w - 1; x >= 0; x--)//R to L
                    {
                        Color pix = bmp.GetPixel(x, y);
                        double diff = Snake.RGB_Distance(snakeColor, pix);
                        if (diff < tolerance)
                        {
                            snakeColor = pix;
                        }
                        //else keep current color
                        snake.SetPixel(x, y, snakeColor);
                    }
                }
            }

            snake.Save("snake.png");
        }

        static double RGB_Distance(Color current, Color next)
        {
            int dr = current.R - next.R;
            int db = current.B - next.B;
            int dg = current.G - next.G;
            double d = Math.Pow(dr, 2) + Math.Pow(db, 2) + Math.Pow(dg, 2);
            d = Math.Sqrt(d) / (255 * Math.Sqrt(3));
            return d;
        }

        static void Main(string[] args)
        {
            try
            {
                string file = "input.png";
                Image img = Image.FromFile(file);
                double tolerance = 0.03F;
                Snake.MakeSnake(img, tolerance);
                Console.WriteLine("Complete");
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }

        }
    }
}

परिणाम छवि सहिष्णुता = 0.1

यहाँ छवि विवरण दर्ज करें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.