मुक्तहस्त लाल वृत्त

Question

Http://meta.stackoverflow.com पर , हमारे पास अपनी खुद की कुछ यादें हैं। उनमें से एक फ्रीहैंड रेड सर्कल्स है।

इस पोस्ट को देखें :

तो, चुनौती है,

आप कोड के साथ ... मुक्त लाल हलकों आकर्षित कर सकते हैं?

अतिरिक्त प्रतिबंध:

• आप इनपुट के रूप में एक इमेज लेंगे , और आपको फ्रीहैंड रेड सर्कल के साथ इमेज को आउटपुट करना होगा।
• अनुमानित होना चाहिए, यानी एक ही छवि इनपुट के परिणामस्वरूप एक ही आउटपुट होना चाहिए। आप यादृच्छिकता का उपयोग कर सकते हैं, लेकिन परिणाम उसी इनपुट के अनुरूप होना चाहिए।
• आउटपुट इनपुट के रूप में बिल्कुल वैसा ही होना चाहिए, जैसे कि सर्कल के अलावा (कोई अन्य परिवर्तन नहीं)।
• मुक्तहस्त लाल वृत्त को मुक्तहस्त देखना चाहिए (कोई पूर्ण वृत्त नहीं!), लाल होना (स्पष्ट रूप से), और आम तौर पर एक चक्र (कोई यादृच्छिक स्किगली रेखाएं) नहीं दिखना चाहिए।

---

यह एक लोकप्रियता-प्रतियोगिता है , इसलिए मार्च 2014 की शुरुआत में सबसे अधिक उत्थान के साथ जवाब जीत जाएगा। "फ्रीहैंड रेड सर्कल" के अलावा कोई विशिष्ट लक्ष्य नहीं है, इसलिए जितना संभव हो उतना रचनात्मक हो ताकि आपको सबसे अधिक उत्थान मिले! (जितना संभव हो सके निष्पक्ष होने के लिए, मैं नियमों का पालन करने वाले किसी भी उत्तर को आगे बढ़ा दूंगा।)

Comments

मुझे लगता है कि इसके लिए थोड़ा और स्पष्टीकरण चाहिए। क्या हम a) एक सादे सफेद कैनवास पर एक वृत्त के अलावा कुछ भी नहीं बनाते हैं, b) पाठ युक्त एक छवि लेते हैं, और पाठ खंड के चारों ओर एक वृत्त खींचते हैं, या c) एक पाठ लेते हैं, और पाठ की एक छवि बनाते हैं इसके चारों ओर घेरा?

— प्राइमो

+1 से @primo। इसके अलावा, अन्य बातों पर भी विचार किया जाना चाहिए: यदि हमें केवल इतना करना है कि एक वृत्त खींचना है, तो क्या यह हर बार एक ही चक्र है या क्या कार्यक्रम को अलग-अलग मंडलियों को खींचने में सक्षम होने की आवश्यकता है - और क्या वे वृत्त सिर्फ यादृच्छिक रूप से भिन्न हैं, या किसी तरह उपयोगकर्ता इनपुट द्वारा निर्दिष्ट? क्या सर्कल के आकार या आकार को निर्धारित करने के लिए प्रोग्राम को उपयोगकर्ता इनपुट से निपटने में सक्षम होना चाहिए? क्या यह मायने रखता है कि छवि आउटपुट किस प्रारूप में है या कोई व्यक्ति केवल कुछ चतुर ASCII कला के साथ आ सकता है?

— इज़्ज़ी

मुझे लगता है कि इसका जवाब "यह एक लोकप्रियता प्रतियोगिता है, इसलिए अपने कोड-गोल्फ दोस्तों को प्रभावित करें"

— मैकके

मुझे नहीं पता कि इस प्रश्न के बारे में क्या अस्पष्ट है। @ इस्ज़ी - कुंजी शब्द मुक्तहस्त है। पेंट या जीआईएमपी खोलें और कुछ फ्रीहैंड सर्कल बनाएं, क्या वे सभी समान दिखते हैं? विवरण और लिंक से, ऐसा लगता है कि आपको किसी चीज़ के चारों ओर वृत्त खींचना है, जो कि X & Y और आकार का होगा। इससे क्या फर्क पड़ता है कि आप किस फ़ाइल प्रारूप का उपयोग करते हैं? यदि आप पीएनजी, जेपीईजी या जो भी चाहते हैं तो इसे एक कनवर्टर के माध्यम से चलाएं।

मैं मैकके के साथ विश्वास करता हूं। यदि आप बहुत सारे अपवोट चाहते हैं, तो यादृच्छिक फ्रीहैंड सर्कल बनाएं। अन्यथा, अपने सर्कल को हार्डकोड करें

— होशे 250

Answer 1

सी - लगभग 750 720 बाइट अगर निचोड़ा गया ^*

मुझे लगता है कि मैं कुछ ऐसा करने के लिए आया था, जो मुक्तहस्त-पर्याप्त रूप से दिखता है।

• एक यादृच्छिक कोण पर शुरू होता है
• एक पूर्ण चक्र प्लस या थोड़ा सा खींचता है
• एक मोटी स्क्वीगली लाइन का उपयोग करता है (शायद बहुत कम ही !)
• एक MAGICनंबर बदलकर अनुकूलन योग्य है

संकलित करें:

gcc -o freehand freehand.c -lm

Daud:

./freehand [X center in % W] [Y center in % H] [radius in % diagonal] < [PPM file input] > [PPM file output]

उदाहरण:

./freehand 28.2 74.5 3.5 < screenshot.ppm > freehand.ppm

इससे पहले:

उपरांत:

कोड:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#define MAGIC      42
#define UNIFORM(x) ((x) * (double)rand() / (double)RAND_MAX)

typedef struct {unsigned char r, g, b;} RGB;

int main(int argc, char **argv)
{
    int W, H, i, f, g, x, y;
    double X, Y, R, a, r;
    RGB *p;

    srand(MAGIC);

    if (argc != 4 || scanf("P6 %d %d 255\n", &W, &H) != 2)
        return 1;

    p = malloc(sizeof(RGB) * W * H);

    fread(p, sizeof(RGB), W * H, stdin);

    X = W * atof(argv[1]) / 100.0;
    Y = H * atof(argv[2]) / 100.0;
    R = hypot(W, H) * atof(argv[3]) / 100.0;

    for (a = UNIFORM(M_PI), i = 2.0 * M_PI * R + UNIFORM(R / 4.0), r = R; i > 0; i--, a += 1.0 / R)
    {
        r += UNIFORM(2.0) - 1.0;
        f = sin(a) * r + X;
        g = cos(a) * r + Y;

        for (x = f - 2; x <= f + 2; x++)
        {
            for (y = g - 2; y <= g + 2; y++)
            {
                if (x >= 0 && x < W && y >= 0 && y < H)
                {
                    RGB *s = p + y * W + x;
                    s->r = 255;
                    s->g = 0;
                    s->b = 0;
                }
            }
        }
    }

    printf("P6 %d %d 255\n", W, H);
    fwrite(p, sizeof(RGB), W * H, stdout);

    free(p);

    return 0;
}

* और का उपयोग कर Uके लिए UNIFORMऔर Mके लिएMAGIC

Answer 2

सी + जीडी पुस्तकालय

किसी भी पुराने घेरे को आकर्षित करने के बजाय, मैंने सोचा कि चित्र में कुछ लाल खोजने और उसके चारों ओर एक घेरा बनाने में मज़ा आएगा।

यहाँ प्राप्त परिणामों के कुछ उदाहरण हैं के साथ एक कुछ तस्वीरें से विकिमीडिया कॉमन्स :

और यहाँ कोड है। यह थोड़ा गड़बड़ है, लेकिन इसका पालन करना बहुत मुश्किल नहीं है, मुझे उम्मीद है:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gd.h>

#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))

/* Used for image segmentation */
int floodfill(int *tmp, int i, int w, int id) {
  int np=1;
  tmp[i]=id;
  if (tmp[i-w-1]<0) np+=floodfill(tmp,i-w-1,w,id);
  if (tmp[i-w]<0) np+=floodfill(tmp,i-w,w,id);
  if (tmp[i-w+1]<0) np+=floodfill(tmp,i-w+1,w,id);
  if (tmp[i-1]<0) np+=floodfill(tmp,i-1,w,id);
  if (tmp[i+1]<0) np+=floodfill(tmp,i+1,w,id);
  if (tmp[i+w-1]<0) np+=floodfill(tmp,i+w-1,w,id);
  if (tmp[i+w]<0) np+=floodfill(tmp,i+w,w,id);
  if (tmp[i+w+1]<0) np+=floodfill(tmp,i+w+1,w,id);
  return np;
}

int main(int argv, char *argc[]) {
  FILE          *infile,*outfile;
  gdImagePtr    img;
  int           *t, *tmp;
  int           w,h,x,y,r,g,b;
  int           c,redness,rgb;
  int           i,np,max,min,thresh;
  int           xt,yt,n;
  int           areaID,size,maxID;
  double        xmin,ymin,xmax,ymax,rad,r0,th;
  gdPoint       v[33];


  /* Check command line and open source JPEG file */
  if (argv!=3) return printf("Usage: %s <in.jpg> <out.jpg>\n",argc[0]);
  if (!(infile=fopen(argc[1],"r"))) return printf("Can't open <%s>\n",argc[1]);
  if (!(img=gdImageCreateFromJpeg(infile))) return printf("Bad JPEG: <%s>\n",argc[1]);
  fclose(infile);

  /* Extract red pixels and auto-threshold */
  w=img->sx;
  h=img->sy;
  np=w*h;
  t=tmp=calloc(np,sizeof(int));
  for (max=0,min=255,y=1;y<h-1;y++) {
    for (x=1;x<w-1;x++) {
      rgb=gdImageGetTrueColorPixel(img,x,y);
      r = (rgb&0xff0000)>>16;
      g = (rgb&0xff00)>>8;
      b = rgb&0xff;
      redness = max(0,r-(max(g,b)+abs(g-b)));
      if (redness>max) max=redness;
      if (redness<min) min=redness;
      *t++ = redness;
    }
    t += 2;
  }
  thresh = (max+min)/2;
  for (t=tmp,i=0;i<np;i++,t++) *t=((*t>thresh)?-1:0);

  /* Label each area detected */
  areaID=1;
  maxID=0;
  max=-1;
  for (t=tmp,i=0;i<np;i++,t++) {
    if (*t<0) {
      size=floodfill(tmp,i,w,areaID);
      if (size>max) {
        max = size;
        maxID = areaID;
      }
      areaID++;
    }
  }

  /* Calculate centre coordinates and area */
  if (max>0) {
    xt=yt=n=xmax=ymax=0;
    xmin=w; ymin=h;
    for (t=tmp,y=0;y<h;y++) {
      for (x=0;x<w;x++) {
        if (*t++==maxID) {
          xt+=x;
          yt+=y;
          n++;
          if (x<xmin) xmin=x;
          if (y<ymin) ymin=y;
          if (x>xmax) xmax=x;
          if (y>ymax) ymax=y;
        }
      }
    }
    x = xt/(2*n) + (xmax+xmin)/4;
    y = yt/(2*n) + (ymax+ymin)/4;

    r0 = max(20,min(min(w,h),max(xmax-xmin,ymax-ymin))/2);
  }
  /* Default circle if nothing found */
  else {
    x=w/2; y=h/2; r0=min(w,h)/3;
  }

  /* Draw a red circle */
  for (th=4.0,i=0;i<33;i++) {
    rad = r0 * (1.2 + (" ,<MYZVSB>@EJIOSWZfgb^bbfgeZTOI@2"[i]-87)/160.0);
    v[i].x = x + rad * sin(th);
    v[i].y = y + rad * cos(th);
    th += 0.22;
  }
  gdImageSetThickness(img,7);
  c = gdImageColorAllocate(img,255,0,0);
  gdImageOpenPolygon(img,v,33,c);

  /* Output results to file */
  printf("Saving...\n");
  if (!(outfile=fopen(argc[2],"w"))) {
    return printf("Can't open <%s> for writing\n",argc[2]);
  }
  gdImageJpeg(img,outfile,85);
  fclose(outfile);
  gdImageDestroy(img);
  printf("Finished\n");
  return 0;
}

---

नोट: मार्कडाउन ने टिप्पणियों में मेरे लिंक को गड़बड़ कर दिया है, इसलिए मैं सिर्फ यह बताऊंगा कि कोड चित्र में लाल के सभी क्षेत्रों की पहचान करने के लिए विभाजन का उपयोग करता है , और फिर इनमें से सबसे बड़ा घेरा बनाता है। उदाहरण के लिए, यह छवि :

निम्नलिखित उत्पादन का उत्पादन:

Comments

अच्छी नौकरी! ;) कुछ पर जोर देने के लिए उन्हें खींचने के विषय के साथ अधिक जाता है। लेकिन मैं उत्सुक हूं कि अगर दो लाल वस्तुएं होतीं तो वह क्या करतीं ...? (+1)

— दरवाज़े

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

— स्क्वीश ossifrage

Answer 3

मेथेमेटिका

ClearAll[f]
f[image_,rad_, xPos_:.5,yPos_:.5,color_:Darker[Red,0.3],thick_:.01,axes_:False]:=
 Module[{i=ImageDimensions[image],rr,y=SeedRandom[2]},
 rr:=RandomReal[{-.1,.1}];
 Show[image,Graphics[{color,JoinForm["Round"],CapForm["Round"],Thickness[thick],
 Line[t=Table[{rad i[[2]] (Cos[z]+rr)+i[[1]]xPos,rad i[[2]] (Sin[z]+rr)+i[[2]] yPos},
 {z,0, 2 Pi+2Pi/12,Pi/12}]]}],Axes-> axes]]

f निम्नलिखित पैरामीटर लेता है:

• छवि: वह छवि जिसे एक सर्कल के साथ चिह्नित किया जाएगा
• त्रिज्या: छवि चौड़ाई के अंश में वृत्त की त्रिज्या
• xPos: x के साथ वृत्त के केंद्र की स्थिति, 0 से 1 तक (डिफ़ॉल्ट = .5)।
• yPos: 0 से 1 तक (डिफ़ॉल्ट = .5), साथ में वृत्त के केंद्र की स्थिति।
• रंग: स्याही का रंग (डिफ़ॉल्ट = गहरा लाल)
• मोटाई: स्ट्रोक मोटाई (डिफ़ॉल्ट = .01)
• कुल्हाड़ी: चाहे कुल्हाड़ी दिखाना हो (डिफ़ॉल्ट = गलत)

---

उदाहरण

text = Import["text.png"]
f[text,.13,.58,.23]

एक अलग त्रिज्या, स्थान, नीला रंग, मोटा स्ट्रोक, प्रदर्शित कुल्हाड़ियों।

f[text,.22,.7,.5,Blue,.015,True]

Comments

वाह बहुत अच्छा! क्या यह यादृच्छिक है, हालांकि? (यह एक ही इनपुट के लिए एक ही उत्पादन का उत्पादन करना चाहिए।)

— दरवाज़े

मैंने एक सच्चे सर्कल से विचलन के लिए यादृच्छिकता का उपयोग किया। मुझे लगा कि ठीक है। यदि नहीं, तो मैं आकार को सख्त कर सकता हूं।

— डेविड एफसी

"अनुमानित होना चाहिए, अर्थात एक ही छवि इनपुट के परिणामस्वरूप एक ही आउटपुट होना चाहिए। आप यादृच्छिकता का उपयोग कर सकते हैं, लेकिन परिणाम इस इनपुट के लिए सुसंगत होना चाहिए।" मैथेमेटिका में एक वरीयता प्राप्त आरएनजी प्राप्त करने का कोई तरीका होना चाहिए, है ना?

— दरवाज़े

हाँ, SeedRandomचाल करने के लिए लगता है।

— डेविड फ़िक्स

ठीक है, महान! +1

— दरवाज़े