Reptillian

October 26, 2021

I do have a earlier code that works, however, it involves separate propRules. It works, however at the start, some controls are enabled until I change options and that is when behavior is correct. Changing the defaults is the easiest solution.

I wanted the control if (the checkbox is not checked) AND (any one of the three list selections is made).

As I'm new to indirectui as I barely use it except in rare cases, I would like a example of what you mean.

October 26, 2021

Let's say I have a plugin option. The plugin option should only activates if a boolean option is checked off, and any of three dropdown option.

Here's what I have:

            propRules.Add(new ReadOnlyBoundToNameValuesRule(PropertyNames.Points,true,
                (PropertyNames.Use_clipboard_as_tile, false),
                (PropertyNames.Pretile_mode, Pretile_modeOptions.Pretile_modeOption18),
                (PropertyNames.Pretile_mode, Pretile_modeOptions.Pretile_modeOption21),
                (PropertyNames.Pretile_mode, Pretile_modeOptions.Pretile_modeOption22)
                ));

I want PropertyNames.Point to be only activated if clipboard option is set to false, and when the dropdown option is set to any of these option. Otherwise, it is grayed out.

I don't know how to explain this better, but hopefully, this gets the idea.

Also, from the other thread, this always is true:

            propRules.Add(new ReadOnlyBoundToNameValuesRule(PropertyNames.Thickness, true, new TupleStruct<object, object>[] {
                new TupleStruct<object, object>(PropertyNames.Use_clipboard_as_tile, false),
                new TupleStruct<object, object>(PropertyNames.Pretile_mode,Pretile_modeOptions.Pretile_modeOption22)
            }));

October 21, 2021

I think I have a better idea. Do what @otuncelli did, but with resize applied and lower tolerance. Then, use the alpha channel to cover up all the way to the line and process it from there.

I don't know how to use ImageMagick, and I tried to do this in G'MIC. I will refer you to @otuncelli and discuss.pixls.us (if you go the g'mic route) forum for help on this

October 11, 2021

41 minutes ago, BDP said:

I'm using the latest PDN, and forced an update to the G'Mic filters, and I don't see the above filter. Even did a search. Am I missing something?

Brian

If it doesn't appear, then that means the current version of G'MIC is no longer supported. G'MIC 3 is on the horizon, but these are supported by Krita and GIMP. You'll have to wait.

October 11, 2021

New Filter! - Three-Coupled Oscillator

Lszj1JlhRwhMeNOsMwgPe-2eD04otw3Ae5Q92FaE

October 8, 2021

11 hours ago, Rick Brewster said:

2) it must be installed to its own folder within Effects/FileTypes

Requesting a quick clarification as I'm not sure what's the requirement is in my case.

I have GMICSharpNative folder inside the effects folder or document/app files folder. So, every dlls that utilize GMICSharp library must be inside the folder? That's what you mean?

As for the deps thing, going into .NET 5 with this setup is beyond me, so I can't do anything about that unfortunately though I will have assistance from @null54as he worked on this.

October 7, 2021

Looks like I will have to make some changes to my g'mic-pdn project though I find it to be difficult to make changes to suit the new rule.

October 6, 2021

22 minutes ago, Red ochre said:

Have you tried ShapeMaker? 😉

I have a much better idea. We should try assembly language to make shape.

October 4, 2021

Here's my own take on my plugin:

October 2, 2021

Randomly divides the canvas into smaller rectangles, where the initial rectangle is the canvas itself.

Preview:

On the parameters that needs note:

Number of colors - defines the number of color on canvas. If it is 0, then with infinite memory, then infinity number of colors is possible. Otherwise, the number of colors is equal to 2 or higher, and if it is less than 2, then 2 colors.

Loop Limit - Define the maximum loop possible. Sometimes, the generation of rectangle will complete before the loop, so that's why sometimes you don't see changes.

Border(%) - This define the thickness of border. Sometimes border won't show up because of issues regarding to discrete space of raster graphic. I don't know how to explain this.

Installation:

Plugin Files -> Random Rectangle Division.zip

1. Insert the .dll into effect folder of paint.net installation

2. Find it under Texture.

Bugs:

1. Border Color will be active if there is no border. I cannot fix this bug as it requires me to figure out how to make it visible using mathematical operation within variables.

Source code:

CodeLab

Spoiler

// Name: Random Rectangle Division
// Submenu: Texture
// Author: Reptorian.
// Title: Random Rectangle Division
// Version: 1
// Desc: Create randomly divided rectangle on Canvas
// Keywords: Rectangles
// URL: https://forums.getpaint.net/profile/85868-reptillian/
// Help:
#region UICode
IntSliderControl max_divide = 10; // [1,20] Division
IntSliderControl init_add_thick = 1; // [0,100] Additional Thickness
IntSliderControl max_iter = 5; // [2,40] Maximum Division Iteration
IntSliderControl probability = 95; // [0,100] Probability of Division(%)
IntSliderControl max_loop = 2000; // [2000,2097152] Loop Limit
DoubleSliderControl init_border = 100; // [0,100] Border(%)
ReseedButtonControl seed = 0; // Reseed
ColorWheelControl border_color = ColorBgra.FromBgr(0, 0, 0); // [Black] Border Color
ListBoxControl color_choice = 1; // Color Mode|Random RGB|Grayscale
IntSliderControl num_rgb = 0; // [0,100] {color_choice} Number of Random RGB Colors
ReseedButtonControl seed2 = 0; // {color_choice} Reseed Color
#endregion

int [,] Rectangles_Surface;
ColorBgra[] Random_RGB;

Random Seed = new Random();
Random Seed_2 = new Random();
int new_seed,new_seed_2;

List<(int,int,int,int,int)> Modifiable_Rect = new List<(int,int,int,int,int)>{
            (0,0,0,0,0)
};

List<(int,int,int,int,int)> Unmodifiable_Rect = new List<(int,int,int,int,int)>{
            (0,0,0,0,0)
};


bool diff_check(int a)
{
    int mri = max_divide;
    double ds = (double)(a/mri);
    if (mri>1&&(ds<1)){
        while(mri>1&&(ds<1)){
            mri--;
            ds = (double)(a/mri);
        }
    }

    return ds>1;
}


bool pass=false;

Random myRandom,myRandom2;

void split_column(int point,int test_boundary,int border_size){
        bool skip = false;
        int mx=0;
        int np;

        int ri = myRandom.Next(1,max_divide)+1;
        int mri = ri - 1;

        int min_x=Modifiable_Rect[point].Item1;
        int max_x=Modifiable_Rect[point].Item2;
        int min_y=Modifiable_Rect[point].Item3;
        int max_y=Modifiable_Rect[point].Item4;
        int itern=Modifiable_Rect[point].Item5+1;

        Modifiable_Rect.RemoveAt(point);

        int sx = min_x+test_boundary;
        int ex = max_x-test_boundary;

        int diff=ex-sx;
        bool bound_check = diff>test_boundary;
        bool rb;

        int min_v,max_v;

        if (bound_check)
        {
            double ds=(double)(diff/mri);
            if(mri>1&&(ds<=test_boundary))
            {
                while(mri>1&&(ds<=test_boundary))
                {
                    ri--;
                    mri--;
                    ds=(double)(diff/mri);
                }
            }
            if(test_boundary>0||diff>0?(ds>(double)(test_boundary)):true)
            {
                int p=min_x;
                for(int ri_ind=0; ri_ind<ri ; ri_ind++)
                {
                    rb=myRandom.Next(0,99)>(probability-1);
                    if (ri_ind==mri)
                    {
                        if (p>max_x)
                        {
                            p=max_x;
                            if((max_y-min_y)==0){rb=true;}
                        }
                        if (rb || (itern==max_iter))
                        {
                            Unmodifiable_Rect.Add((p,max_x,min_y,max_y,itern));
                        }
                        else
                        {
                            Modifiable_Rect.Add((p,max_x,min_y,max_y,itern));
                        }

                    }
                    else
                    {
                        if(ri_ind==0)
                        {
                            mx=(int)(Math.Round((double)(sx+ds)));
                            min_v=Math.Min(p,mx);
                            max_v=Math.Max(p,mx);
                            np=Math.Min(Math.Max(sx,myRandom.Next(min_v,max_v)),ex);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((p,np,min_y,max_y,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((p,np,min_y,max_y,itern));
                            }
                            p=np+1;
                            if(p>=ex){skip=true;}
                        }
                        else
                        {
                            if(skip){continue;}
                            mx=(int)(Math.Round((double)(mx+ds)));
                            min_v=Math.Min(p,mx);
                            max_v=Math.Max(p,mx);
                            np=Math.Min(Math.Max(p+border_size,myRandom.Next(min_v,max_v)),ex);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((Math.Min(p,ex),np,min_y,max_y,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((Math.Min(p,ex),np,min_y,max_y,itern));
                            }
                            p=np+1;
                        }
                    }
                }
            }
            else
            {
                Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
            }
        }
        else
        {
            Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
        }
}

void split_row(int point,int test_boundary,int border_size){
        bool skip = false;
        int my=0;
        int np;

        int ri = myRandom.Next(1,max_divide)+1;
        int mri = ri - 1;

        int min_x=Modifiable_Rect[point].Item1;
        int max_x=Modifiable_Rect[point].Item2;
        int min_y=Modifiable_Rect[point].Item3;
        int max_y=Modifiable_Rect[point].Item4;
        int itern=Modifiable_Rect[point].Item5+1;

        Modifiable_Rect.RemoveAt(point);

        int sy = min_y+test_boundary;
        int ey = max_y-test_boundary;
        int diff=ey-sy;
        bool bound_check = diff>test_boundary;
        bool rb;

        int min_v,max_v;

        if (bound_check)
        {
            
            double ds=(double)(diff/mri);
            if(mri>1&&(ds<=test_boundary))
            {
                while(mri>1&&(ds<=test_boundary))
                {
                    ri--;
                    mri--;
                    ds=(double)(diff/mri);
                }
            }
            if(test_boundary>0||diff>0?(ds>(double)(test_boundary)):true)
            {
                int p=min_y;
                for(int ri_ind=0; ri_ind<ri ; ri_ind++)
                {
                    rb=myRandom.Next(0,99)>(probability-1);
                    if (ri_ind==mri)
                    {
                        if (p>max_y)
                        {
                            p=max_y;
                            if((max_x-min_x)==0){rb=true;}
                        }
                        if (rb || (itern==max_iter))
                        {
                            Unmodifiable_Rect.Add((min_x,max_x,p,max_y,itern));
                        }
                        else
                        {
                            Modifiable_Rect.Add((min_x,max_x,p,max_y,itern));
                        }

                    }
                    else
                    {
                        if(ri_ind==0)
                        {
                            my=(int)(Math.Round((double)(sy+ds)));
                            min_v=Math.Min(p,my);
                            max_v=Math.Max(p,my);
                            np=Math.Min(Math.Max(sy,myRandom.Next(min_v,max_v)),ey);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((min_x,max_x,p,np,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((min_x,max_x,p,np,itern));
                            }
                            p=np+1;
                            if(p>=ey){skip=true;}
                        }
                        else
                        {
                            if(skip){continue;}
                            my=(int)(Math.Round((double)(my+ds)));
                            min_v=Math.Min(p,my);
                            max_v=Math.Max(p,my);
                            np=Math.Min(Math.Max(p+border_size,myRandom.Next(min_v,max_v)),ey);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((min_x,max_x,Math.Min(p,ey),np,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((min_x,max_x,Math.Min(p,ey),np,itern));
                            }
                            p=np+1;
                        }
                    }
                }
            }
            else
            {
                Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
            }
        }
        else
        {
            Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
        }
}

bool finished_init;

int trs,trs_2,length;

void PreRender(Surface dst, Surface src)
{

    int rs=Seed.Next();
    int rs_2=Seed_2.Next();
    if (!finished_init)
    {
        trs=rs;
        trs_2=rs_2;
    }

    if (Rectangles_Surface==null)
    {
        Modifiable_Rect.RemoveRange(0,1);
        Unmodifiable_Rect.RemoveRange(0,1);
        Rectangles_Surface=new int [src.Width,src.Height];
    }
    else
    {
        Modifiable_Rect.RemoveRange(0,Modifiable_Rect.Count);
        Unmodifiable_Rect.RemoveRange(0,Unmodifiable_Rect.Count);
        Array.Clear(Rectangles_Surface,0,src.Width*src.Height);
    }

    if (new_seed != seed)
    {
        Modifiable_Rect.RemoveRange(0,Modifiable_Rect.Count);
        Unmodifiable_Rect.RemoveRange(0,Unmodifiable_Rect.Count);
        trs=rs;
    }
    else
    {
        if (!finished_init){
            trs=rs;
        }
    }

    if (new_seed_2 != seed2)
    {
        trs_2=rs_2;
    }
    else
    {
        if (!finished_init){
            trs_2=rs_2;     
        }
    }


    myRandom = new Random(trs);
    myRandom2 = new Random(trs_2);

    new_seed = seed;
    new_seed_2 = seed2;

    int width  = src.Width  - 1;
    int height = src.Height - 1;
    int border_size;
    int test_boundary;

    if (init_add_thick>0)
    {
        border_size=init_add_thick+1;
        test_boundary=border_size+1;
    }
    else{
        border_size=0;
        test_boundary=0;
    }

    int border = (int)(Math.Round((double)(init_add_thick*init_border/100)));

    bool contain_border = border>0;
    bool width_check=diff_check(width-border_size*2);
    bool height_check=diff_check(height-border_size*2);

    if (width_check||height_check){
        pass = true;
        Modifiable_Rect.Add((0,width,0,height,0));

        if (width_check&&height_check)
        {
            if (myRandom.Next(0,2)==0)
            {
                split_column(0,test_boundary,border_size);
            }
            else
            {
                split_row(0,test_boundary,border_size);
            }
        }
        else
        {
            if (height_check)
            {
                split_column(0,test_boundary,border_size);
            }
            else
            {
                split_row(0,test_boundary,border_size);
            }
        }

        int arr_point=0;
        int p_ind;

        while(Modifiable_Rect.Count>0)
        {
            p_ind=myRandom.Next(Modifiable_Rect.Count);
            if(myRandom.Next(0,2)==0)
            {
                split_column(p_ind,test_boundary,border_size);
            }
            else
            {
                split_row(p_ind,test_boundary,border_size);
            }
            arr_point++;
            if(arr_point>=max_loop){break;}
        }


        int new_min_x;
        int new_max_x;
        int new_min_y;
        int new_max_y;
        int nv=0;

        int ex,ey,bx,by;

        int bex=src.Width-1-border;
        int bey=src.Height-1-border;

        if (Modifiable_Rect.Count>0)
        {
            for (int i = 0 ; i < Modifiable_Rect.Count ; i++){
                new_min_x=Modifiable_Rect[i].Item1;
                new_max_x=Modifiable_Rect[i].Item2;
                new_min_y=Modifiable_Rect[i].Item3;
                new_max_y=Modifiable_Rect[i].Item4;
                ex = new_max_x+1;
                ey = new_max_y+1;
                bx = new_min_x + border;
                by = new_min_y + border;
                for (int x = new_min_x ; x<ex ; x++)
                {
                    for (int y = new_min_y ; y<ey ; y++)
                    {
                        if (x < bx || y < by || x > bex || y > bey)
                        {
                            Rectangles_Surface[x,y]=-1;
                        }
                        else
                        {
                            Rectangles_Surface[x,y]=nv;
                        }
                        
                    }
                }
                nv++;
            }
        }


        if (Unmodifiable_Rect.Count>0)
        {
            for (int j = 0 ; j < Unmodifiable_Rect.Count ; j++)
            {
                new_min_x=Unmodifiable_Rect[j].Item1;
                new_max_x=Unmodifiable_Rect[j].Item2;
                new_min_y=Unmodifiable_Rect[j].Item3;
                new_max_y=Unmodifiable_Rect[j].Item4;
                ex=new_max_x+1;
                ey=new_max_y+1;
                bx = new_min_x + border;
                by = new_min_y + border;
                for (int x = new_min_x ; x<ex ; x++)
                {
                    for (int y = new_min_y ; y<ey ; y++)
                    {
                        if (x < bx || y < by || x > bex || y > bey)
                        {
                            Rectangles_Surface[x,y]=-1;
                        }
                        else
                        {
                            Rectangles_Surface[x,y]=nv;
                        }
                        
                    }
                }
                nv++;
            }
        }
        length = nv+1;
        if (color_choice==0){
            byte tb,tg,tr;
            Random_RGB = new ColorBgra[length];
            for (int n = 0 ; n < length ; n++)
            {
                tb=(byte)(myRandom2.Next(256));
                tg=(byte)(myRandom2.Next(256));
                tr=(byte)(myRandom2.Next(256));
                Random_RGB[n]=ColorBgra.FromBgr(tb,tg,tr);
            }
        }
    }

    finished_init = true;
}

void Render(Surface dst, Surface src, Rectangle rect)
{
    // Delete any of these lines you don't need

    byte v;
    double rescale=(double)(length)/255;

    int total_colors=Math.Max(num_rgb,2);
    if (pass)
    {
        for (int y = rect.Top; y < rect.Bottom; y++)
        {
            if (IsCancelRequested) return;
            for (int x = rect.Left; x < rect.Right; x++)
            {
                if (Rectangles_Surface[x,y]==-1)
                {
                    dst[x,y]=border_color;
                }
                else
                {
                    if (color_choice==0)
                    {
                        if (num_rgb>0)
                        {
                            dst[x,y]=Random_RGB[Rectangles_Surface[x,y]%total_colors];
                        }
                        else
                        {
                            dst[x,y]=Random_RGB[Rectangles_Surface[x,y]];
                        }                       
                    }
                    else
                    {
                        v=(byte)((int)(Math.Round((double)(Rectangles_Surface[x,y])/rescale)));
                        dst[x,y]=ColorBgra.FromBgr(v,v,v);
                    }
                }
            }
        }
    }
}

G'MIC

Spoiler

rep_random_rectangular_division:
skip ${2=0},${3=5},${4=95%},${5=5000},${6=}
check "$4>0"
repeat $! l[$>]
 _rep_random_rectangular_division $*
endl done
_rep_random_rectangular_division:
skip ${2=0},${3=5},${4=95%},${5=5000},${6=}

r 100%,100%,1,1

1,1,1,5 #Modifiable Rectangle Array
1,1,1,5 #Unmodifiable Rectangle Array

eval ${-math_lib}"
 if(narg($6),srand($6););
 const ww=w#-3-1;
 const hh=h#-3-1;
 const max_split=max(1,int(abs($1)));
 const internal_space=int(abs($2));
 const test_boundary=internal_space?(internal_space+1);
 const max_iter=max(2,round(abs($3)));
 const odd=cut($4,0,1);
 const arr_limit=round(abs($5));

 diff_check(a)=(
  mri=max_split;
  ds=a/mri;
  if(mri>1&&ds<1,
   while(mri>1&&ds<1,
    mri--;
    ds=a/mri;
   );
  );
  ds>1;
 );

 width_check=diff_check(ww-internal_space*2);
 height_check=diff_check(hh-internal_space*2);

 !(width_check||height_check)?run('error inv_dim');

 dar_insert(#-2,[0,ww,0,hh,0]);

 sub_column(v,point)=(
  ri=int(u(1,max_split))+1;
  mri=ri-1;
  sx=v[0]+test_boundary;
  ex=v[1]-test_boundary;
  diff=ex-sx;
  bound_check=diff>test_boundary;
  skip=0;
  dar_remove(#-2,point);
  if(bound_check,
   ds=diff/mri;
   if(mri>1&&ds<=test_boundary,
    while(mri>1&&ds<=test_boundary,
     ri--;
     mri--;
     ds=diff/mri;
    );
   );
   if(test_boundary||diff?(ds>test_boundary):1,
    py=[v[2],v[3]];
    iter=v[4]+1;
    p=v[0];
    repeat(ri,ri_ind,
     rb=odd<1?u(0,1)>odd:0;
     ri_ind==mri?(
      if(p>v[1],
       p=v[1];
       if(!(v[3]-v[2]),rb=1;);
      );
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[p,v[1],py,iter]);
      ):(
       dar_insert(#-2,[p,v[1],py,iter]);
      );
     ):
     !ri_ind?(
      mx=sx+ds;
      np=min(max(sx,round(u(p,mx))),ex);
      vp=[p,np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[vp,py,iter]);
      ):(
       dar_insert(#-2,[vp,py,iter]);
      );
      p=np+1;
      if(p>=ex,skip=1;);
     ):(
      if(skip,continue(););
      mx+=ds;
      np=min(max(p+internal_space,round(u(p,mx))),ex);
      vp=[min(p,ex),np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[vp,py,iter]);
      ):(
       dar_insert(#-2,[vp,py,iter]);
      );
      p=np+1;
     );
    );
   ,dar_insert(#-1,v);
   );
  ,dar_insert(#-1,v);
  );
 );

 sub_row(v,point)=(
  ri=int(u(1,max_split))+1;
  mri=ri-1;
  sy=v[2]+test_boundary;
  ey=v[3]-test_boundary;
  diff=ey-sy;
  bound_check=diff>test_boundary;
  skip=0;
  dar_remove(#-2,point);
  if(bound_check,
   ds=diff/mri;
   if(mri>1&&ds<=test_boundary,
    while(mri>1&&ds<=test_boundary,
     ri--;
     mri--;
     ds=diff/mri;
    );
   );
   if(test_boundary||diff?(ds>test_boundary):1,
    px=[v[0],v[1]];
    iter=v[4]+1;
    p=v[2];
    repeat(ri,ri_ind,
     rb=odd<1?u(0,1)>odd:0;
     ri_ind==mri?(
      if(p>v[3],
       p=v[3];
       if(!(v[1]-v[0]),rb=1;);
      );
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[px,p,v[3],iter]);
      ):(
       dar_insert(#-2,[px,p,v[3],iter]);
      );
     ):
     !ri_ind?(
      my=sy+ds;
      np=min(max(sy,round(u(p,my))),ey);
      vp=[p,np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[px,vp,iter]);
      ):(
       dar_insert(#-2,[px,vp,iter]);
      );
      p=np+1;
      if(p>=ey,skip=1;);
     ):(
      if(skip,continue(););
      my+=ds;
      np=min(max(p+internal_space,round(u(p,my))),ey);
      vp=[min(p,ey),np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[px,vp,iter]);
      ):(
       dar_insert(#-2,[px,vp,iter]);
      );
      p=np+1;
     );
    );
   ,dar_insert(#-1,v);
   );
  ,dar_insert(#-1,v);
  );
 );


 v=I[#-2,0];

 width_check&&height_check?(
  u(0,1)<=.5?(
   sub_row(v,0);
  ):(
   sub_column(v,0);
  );
 ):
 width_check?(
  sub_column(v,0);
 ):
 height_check?(
  sub_row(v,0);
 );

 arr_point=0;

 while(dar_size(#-2),
  p_ind=int(u(dar_size(#-2)));
  cv=I[#-2,p_ind];
  u(0,1)<.5?(
   sub_row(cv,p_ind);
  ):(
   sub_column(cv,p_ind);
  );
  arr_point++;
  if(arr_point>=arr_limit,break());
 );

 resize(#-2,1,dar_size(#-2),1,4,0);
 resize(#-1,1,dar_size(#-1),1,4,0);"

a[-2,-1] y

eval. :"begin(
  convert2coords(c)=(
   tl=[c[0],c[2]];
   tr=[c[1],c[2]];
   bl=[c[0],c[3]];
   br=[c[1],c[3]];
   [tl,tr,br,bl];
  );
 );
 polygon(#-2,4,convert2coords(I),1,y);"

rm.
#@gui Random Rectangle Division: fx_rep_rrd,fx_rep_rrd
#@gui :_=separator(),_=note("<b>Main</b>")
#@gui :Division=int(10,1,20)
#@gui :Additional Thickness=int(5,0,100)
#@gui :Maximum Division Iteration=int(5,2,40)
#@gui :Probability of Division(%)=float(95,20,100)
#@gui :Loop Limit=int(50000,1000,2097152)
#@gui :Seed=int(0,0,300)
#@gui :Border(%)=float(35,0,100)
#@gui :_=separator(),_=note("<b>Color</b>")
#@gui :Mode=choice(0,"Grayscale","Palette","Random")
#@gui :Normalize?=bool(1)
#@gui :Palette=choice(12,"BW-{2}","RGB-{3}","B-RGB-{4}","BW-RGB-{5}","CMY-{3}","CMYK-{4}","W-CMYK-{5}","RGBCMY-{6}","1-Bit-RGB-{8}","Aurora-{256}","PLAYPAL-{249}","Sonic Robo Blast 2-{256}","Famicube-{64}","Andrew Kensler - 16","Andrew Kensler - 32","Andrew Kensler - 54","AAP-Micro 12","AAP-16","AAP-64","AAP-SPLENDOR128","DB8","DB16","DB32","DB-ISO22","DimWiddy 17","DimWiddy 23","Endesga-4","Endesga-8","Endesga-16","Endesga-32","Endesga-36","Endesga-64","Juicy-32","Juicy-56","XAIUE-22","15P-DX","20P-DX","24P-DX","Cabana-64","Fantasy 16","Fantasy 24","Tranquil Fantasy 23","Tranquility Plus 39","Faraway 48","Fleja Master Palette-{33}","Koni32","Linear Color Palette Basic-{31}","Vines Flexible Linear Ramps-{38}","Arcade Standard 29","ARQ16","BLK 36","BLK-NEO-{46}","Broken Facility-{40}","Bubblegum-16","Cade 15","Calder 8-{11}","Chromatic16","CD-BAC-{16}","CG Arne-{16}","CPC BOY-{32}","Dinoknight 16","||||-22","FZT Ethereal 16","GZXP-{11}","Indecision-{17}","Island Joy 16","Journey-{64}","Juicy 17","Oak21","Nature's Embrace 55","Nauris-16","Pear 36","Peachy Pop 16-{16}","Pineapple 32","Resurrect 32-{32}","Rosy 42","SLSO-CLR17","Softy 15","SPEC12","Starmancer-{52}","Superb 8","SuperFuture25","Sweetie 16","Taffy 16","Todayland Palette V2-{25}","Vivid-17","Voodo34","Zughy 32","ENOS16","Undertones-17","Equpix 15","Night 16","Star 29","Star 34","Still-Life-{14}","SimpleJPC-16","Acid 15","Battery 24","Clumpy 18","Cthulhu-{16}","Crimso 11","Copper-Tech-{16}","DRZ15A","Eggy 15","Eroge-Copper","Europa 16-{16}","GreyT-bit-{8}","Jewel-{15}","Polar 11","Sheltzy 32","Rube-Goldberg-{9}","BoomBoom-{7}","Generic-8","Matriax8c","NT1H-{26}","Autum 15","Autum 15 [Yellow]","JerryPie 22","Naji 16","Blessing-{5}","Crayola Blind-{9}","Easter Island-{16}","Fairy Tales-{8}","Fuzzy Four-{4}","0xdb-01-{17}","Ocaso-{17}","Pastel-{15}","17 Pastels","Pollen-8","Nopal-12","Sy17","Syz15","TUI-15","Cave-{8}","Psygnosia-{16}","MarshMellow32","Rabbit 7","Finlal 11","Vinik 24","YKB-22","Graveyard-21","Steam Lords-{16}","AAP-RadiantXV-{15}","AAP-Majesty XVII-{17}","Daruda 22","Rust-6","XAIUE-Radiant-{22}","Firestorm-{9}","SuperNova 7","NYX8","OIL6","SGM-Palette 2-{17}","Fornax Void I-{256}","Fornax Void II-{128}","Pixelwave-{12}","Spacey Easter-{17}","Moonlit-39","Petite-8","Petite-8 Afterdark","Autochrome 3","Autochrome 5","GB Default #1-{4}","GB Default #2-{4}","GB Andrade-{4}","GB Blue Seni-{4}","GB Blackzone-{4}","GB Crimson-{4}","GB Didi-{4}","GB Dirty-{4}","GB Arne-{4}","GB Easy-{4}","GB Forest-{4}","GB Harsh Green-{4}","GB Light Green-{4}","GB Nostalgia-{4}","GB Platinum-{4}","GB Kirokaze-{4}","GB PJ-{4}","GB Cyber-{4}","GB Wish-{4}","GB Grapefruit-{4}","GB Ice Cream-{4}","GB Red_Blue-{4}","GB Spacehaze-{4}","GB Chocolate-{4}","GB Purple Dawn-{4}","GB Gray-{4}","ARNE4","HallowPumpkin-{4}","Amiga 2600 NTSC-{128}","Amiga 2600 PAL-{104}","Amiga 2600 SECAM-{8}","Amiga 7800 M.E.S.S-{256}","Amiga 7800-{256}","Amstrad CPC-{27}","Apple II-{15}","CGA-{16}","CGA Mode 0 [Low]-{4}","CGA Mode 0 [High]-{4}","CGA Mode 1 [Low]-{4}","CGA Mode 1 [High]-{4}","CGA Mode 2 [Low]-{4}","CGA Mode 2 [High]-{4}","Commodore 64 [Pepto Interpretation]-{16}","Commodore 64 [Colodore Interpretation]-{16}","Commodore VIC-20-{16}","Colecovision-{15}","Japanese Machine Palette-{16}","Macintosh II-{16}","NES-{52}","PICO-8-{16}","RISC OS-{16}","SAM Coupe-{128}","Thomson MO5-{16}","VGA-{244}","ZX Spectrum-{15}","GNOME 32-{32}","Electronic Crayon 22","Chip16","MSX-{15}","Deluxe Paint-{222}","Legacy Paint-{16}","XP Paint-{28}","Vista Paint-{28}")
#@gui :Color Space=choice(0,"RGB","HSI")
#@gui :Number of Color=int(0,0,100)
#@gui :Seed=int(0,0,100000)
#@gui :Border=color(0,0,0)
#@gui :_=separator(),_=note("<small>Author: Reptorian. Latest Update: <i>2021/09/26</i>.</small>")
fx_rep_rrd:
border_size={max(0,round($2*$7/100))}
repeat $! l[$>]
 rep_random_rectangular_division ${1-3},$4%,${5-6}

 if $8==0
  if $9 n. 0,255 fi
  to_rgb.
 elif $8==1 pal $10 {w},1,1,1,begin(srand($13));u pixelsort.. +,x,[-1] rm.
 else
  if $11 {$12?$12:iM+1},1,1,3,begin(srand($13));[u(360),u(1),u(1)]
  else {$12?$12:iM+1},1,1,3,begin(srand($13));[u(255),u(255),u(255)]
  fi
 fi

 if $border_size +rep_create_border_for_rrd[0] $border_size fi

 if $8
  map[0] [1],2 rm[1]
  if $11&&$8==2 hsi2rgb[0] fi
 fi

 if $border_size
  eval. i?I(#0)=[${14-16}];
 fi

 k[0]
endl done
u "{$1}"\
"{$2}"\
"{$3}"\
"{$4}"\
"{$5}"\
"{$6}"\
"{$7}"\
"{$8}"\
"{$9}"_{!$8?2}\
"{$10}"_{$8==1?2}\
"{$11}"_{$8==2?2}\
"{$12}"_{$8==2?2}\
"{$13}"_{$8?2}\
"{$14,$15,$16}"_{$border_size?2:1}
+rep_create_border_for_rrd:
+f (i!=j(-1,0))||(i!=j(0,-1))
dilate. $1
f. i||x<$1||y<$1||x>(w-$1-1)||y>(h-$1-1)

October 1, 2021

14 minutes ago, MJW said:

one of those things I always intended to read carefully and understand, but never got around to it. Perhaps someone (maybe even me) can do so, and write a tutorial on the matter.

I would appreciate that if you could. Also to anyone else that volunteer to this.

October 1, 2021

I think I'm just gonna leave it with this uncomplete code. Turns out it's not achievable:

Here's what I get (hence why I don't think it can be achieved):

unknown.png?width=1073&height=621

The expected output:

unknown.png?width=621&height=621

With more work, it can look like this: https://cdn.discordapp.com/attachments/880256029705773099/893671307558916157/unknown.png

// Name:
// Submenu:
// Author:
// Title:
// Version:
// Desc:
// Keywords:
// URL:
// Help:
#region UICode
IntSliderControl max_divide = 10; // [1,20] Division
IntSliderControl init_add_thick = 1; // [0,100] Additional Thickness
IntSliderControl max_iter = 5; // [2,40] Maximum Division Iteration
IntSliderControl probability = 95; // [0,100] Probability of Division(%)
IntSliderControl max_loop = 2000; // [2000,2097152] Loop Limit
DoubleSliderControl border = 10; // [0,100] Border(%)
ReseedButtonControl seed = 0; // Reseed
#endregion
#if DEBUG
#endif

ColorBgra[,] Rectangles_Surface;
ColorBgra Empty_Color=ColorBgra.Black;

Random Seed = new Random();
int new_seed;

List<(int,int,int,int,int)> Modifiable_Rect = new List<(int,int,int,int,int)>{
            (0,0,0,0,0)
};

List<(int,int,int,int,int)> Unmodifiable_Rect = new List<(int,int,int,int,int)>{
            (0,0,0,0,0)
};


bool diff_check(int a)
{
    int mri = max_divide;
    double ds = (double)(a/mri);
    if (mri>1&&(ds<1)){
        while(mri>1&&(ds<1)){
            mri--;
            ds = (double)(a/mri);
        }
    }

    return ds>1;
}


bool pass=false;

Random myRandom;

void split_column(int point,int test_boundary,int border_size){
        bool skip = false;
        int mx=0;
        int np;

        int ri = myRandom.Next(1,max_divide)+1;
        int mri = ri - 1;

        int min_x=Modifiable_Rect[point].Item1;
        int max_x=Modifiable_Rect[point].Item2;
        int min_y=Modifiable_Rect[point].Item3;
        int max_y=Modifiable_Rect[point].Item4;
        int itern=Modifiable_Rect[point].Item5+1;

        Modifiable_Rect.RemoveAt(point);

        int sx = min_x+test_boundary;
        int ex = max_x-test_boundary;

        bool bound_check = (ex-sx)>test_boundary;
        bool rb;

        int min_v,max_v;

        if (bound_check)
        {
            int diff=ex-sx;
            double ds=(double)(diff/mri);
            if(mri>1&&(ds<=test_boundary))
            {
                while(mri>1&&(ds<=test_boundary))
                {
                    ri--;
                    mri--;
                    ds=(double)(diff/mri);
                }
            }
            if(((test_boundary>0)||(diff>0))?(ds>(double)(test_boundary)):true)
            {
                int p=min_x;
                for(int ri_ind=0; ri_ind<ri ; ri_ind++)
                {
                    rb=myRandom.Next(0,99)>(probability-1);
                    if (ri_ind==mri)
                    {
                        if (p>max_x)
                        {
                            p=max_x;
                            if((max_y-min_y)==0){rb=true;}
                        }
                        if (rb || (itern==max_iter))
                        {
                            Unmodifiable_Rect.Add((p,max_x,min_y,max_y,itern));
                        }
                        else
                        {
                            Modifiable_Rect.Add((p,max_x,min_y,max_y,itern));
                        }

                    }
                    else
                    {
                        if(ri_ind==0)
                        {
                            mx=(int)(Math.Round((double)(sx+ds)));
                            min_v=Math.Min(p,mx);
                            max_v=Math.Max(p,mx);
                            np=Math.Min(Math.Max(sx,myRandom.Next(min_v,max_v)),ex);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((p,np,min_y,max_y,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((p,np,min_y,max_y,itern));
                            }
                            p=np+1;
                            if(p>=ex){skip=true;}
                        }
                        else
                        {
                            if(skip){continue;}
                            mx=(int)(Math.Round((double)(mx+ds)));
                            min_v=Math.Min(p,mx+1);
                            max_v=Math.Max(p,mx+1);
                            np=Math.Min(Math.Max(p+border_size,myRandom.Next(min_v,max_v)),ex);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((Math.Min(p,ex),np,min_y,max_y,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((Math.Min(p,ex),np,min_y,max_y,itern));
                            }
                            p=np+1;
                        }
                    }
                }
            }
            else
            {
                Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
            }
        }
        else
        {
            Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
        }
}

void split_row(int point,int test_boundary,int border_size){
        bool skip = false;
        int my=0;
        int np;

        int ri = myRandom.Next(1,max_divide)+1;
        int mri = ri - 1;

        int min_x=Modifiable_Rect[point].Item1;
        int max_x=Modifiable_Rect[point].Item2;
        int min_y=Modifiable_Rect[point].Item3;
        int max_y=Modifiable_Rect[point].Item4;
        int itern=Modifiable_Rect[point].Item5+1;

        Modifiable_Rect.RemoveAt(point);

        int sy = min_y+test_boundary;
        int ey = max_y-test_boundary;

        bool bound_check = (ey-sy)>test_boundary;
        bool rb;

        int min_v,max_v;

        if (bound_check)
        {
            int diff=ey-sy;
            double ds=(double)(diff/mri);
            if(mri>1&&(ds<=test_boundary))
            {
                while(mri>1&&(ds<=test_boundary))
                {
                    ri--;
                    mri--;
                    ds=(double)(diff/mri);
                }
            }
            if(((test_boundary>0)||(diff>0))?(ds>(double)(test_boundary)):true)
            {
                int p=min_x;
                for(int ri_ind=0; ri_ind<ri ; ri_ind++)
                {
                    rb=myRandom.Next(0,99)>(probability-1);
                    if (ri_ind==mri)
                    {
                        if (p>max_y)
                        {
                            p=max_y;
                            if((max_x-min_x)==0){rb=true;}
                        }
                        if (rb || (itern==max_iter))
                        {
                            Unmodifiable_Rect.Add((min_x,max_x,p,max_y,itern));
                        }
                        else
                        {
                            Modifiable_Rect.Add((min_x,max_x,p,max_y,itern));
                        }

                    }
                    else
                    {
                        if(ri_ind==0)
                        {
                            my=(int)(Math.Round((double)(sy+ds)));
                            min_v=Math.Min(p,my);
                            max_v=Math.Max(p,my);
                            np=Math.Min(Math.Max(sy,myRandom.Next(min_v,max_v)),ey);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((min_x,max_x,p,np,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((min_x,max_x,p,np,itern));
                            }
                            p=np+1;
                            if(p>=ey){skip=true;}
                        }
                        else
                        {
                            if(skip){continue;}
                            my=(int)(Math.Round((double)(my+ds)));
                            min_v=Math.Min(p,my+1);
                            max_v=Math.Max(p,my+1);
                            np=Math.Min(Math.Max(p+border_size,myRandom.Next(min_v,max_v)),ey);
                            if (rb || (itern==max_iter))
                            {
                                Unmodifiable_Rect.Add((min_x,max_x,Math.Min(p,ey),np,itern));
                            }
                            else
                            {
                                Modifiable_Rect.Add((min_x,max_x,Math.Min(p,ey),np,itern));
                            }
                            p=np+1;
                        }
                    }
                }
            }
            else
            {
                Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
            }
        }
        else
        {
            Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,itern));
        }
}

void PreRender(Surface dst, Surface src)
{

    if (Rectangles_Surface==null)
    {
        Modifiable_Rect.RemoveRange(0,1);
        Unmodifiable_Rect.RemoveRange(0,1);
        Rectangles_Surface=new ColorBgra [src.Width,src.Height];
    }
    else
    {
        Modifiable_Rect.RemoveRange(0,Modifiable_Rect.Count);
        Unmodifiable_Rect.RemoveRange(0,Unmodifiable_Rect.Count);
        Array.Clear(Rectangles_Surface,0,src.Width*src.Height);
    }

    if (new_seed != seed)
    {
        Modifiable_Rect.RemoveRange(0,Modifiable_Rect.Count);
        Unmodifiable_Rect.RemoveRange(0,Unmodifiable_Rect.Count);
        myRandom = Seed;
    }
    else
    {
        myRandom = new Random(int.MaxValue);
    }

    new_seed = seed;

    int width  = src.Width  - 1;
    int height = src.Height - 1;
    int border_size;
    int test_boundary;

    if (init_add_thick>0)
    {
        border_size=init_add_thick+1;
        test_boundary=border_size+1;
    }
    else{
        border_size=0;
        test_boundary=0;
    }

    bool width_check=diff_check(width-border_size*2);
    bool height_check=diff_check(height-border_size*2);

    if (width_check||height_check){
        pass = true;
        Modifiable_Rect.Add((0,width,0,height,0));

        //split_row(0,test_boundary,border_size);

        if (width_check&&height_check)
        {
            if (myRandom.Next(0,2)==0)
            {
                split_column(0,test_boundary,border_size);
            }
            else
            {
                split_row(0,test_boundary,border_size);
            }
        }
        else
        {
            if (height_check)
            {
                split_column(0,test_boundary,border_size);
            }
            else
            {
                split_row(0,test_boundary,border_size);
            }
        }

        int arr_point=0;
        int p_ind;

        while(Modifiable_Rect.Count>0){
            p_ind=myRandom.Next(Modifiable_Rect.Count);
            if(myRandom.Next(0,2)==0)
            {
                split_column(p_ind,test_boundary,border_size);
            }
            else
            {
                split_row(p_ind,test_boundary,border_size);
            }
            arr_point++;
            if(arr_point>=max_loop){break;}
        }


        int new_min_x;
        int new_max_x;
        int new_min_y;
        int new_max_y;
        int nv=0;

        int ex,ey;

        ColorBgra Temp_Color;

        int tr,tg,tb;

        if (Modifiable_Rect.Count>0)
        {
            for (int i = 0 ; i < Modifiable_Rect.Count ; i++){
                new_min_x=Modifiable_Rect[i].Item1;
                new_max_x=Modifiable_Rect[i].Item2;
                new_min_y=Modifiable_Rect[i].Item3;
                new_max_y=Modifiable_Rect[i].Item4;
                ex = new_max_x+1;
                ey = new_max_y+1;
                tr=myRandom.Next(256);
                tg=myRandom.Next(256);
                tb=myRandom.Next(256);
                for (int x = new_min_x ; x<ex ; x++)
                {
                    for (int y = new_min_y ; y<ey ; y++)
                    {
                        Rectangles_Surface[x,y]=ColorBgra.FromBgr((byte)(tb),(byte)(tg),(byte)(tr));
                    }
                }
                nv++;
            }
        }

        if (Unmodifiable_Rect.Count>0)
        {
            for (int j = 0 ; j < Unmodifiable_Rect.Count ; j++)
            {
                new_min_x=Unmodifiable_Rect[j].Item1;
                new_max_x=Unmodifiable_Rect[j].Item2;
                new_min_y=Unmodifiable_Rect[j].Item3;
                new_max_y=Unmodifiable_Rect[j].Item4;
                ex=new_max_x+1;
                ey=new_max_y+1;
                tr=myRandom.Next(256);
                tg=myRandom.Next(256);
                tb=myRandom.Next(256);
                for (int x = new_min_x ; x<ex ; x++)
                {
                    for (int y = new_min_y ; y<ey ; y++)
                    {
                        Rectangles_Surface[x,y]=ColorBgra.FromBgr((byte)(tb),(byte)(tg),(byte)(tr));
                    }
                }
                nv++;
            }
        }

    }
}

void Render(Surface dst, Surface src, Rectangle rect)
{
    // Delete any of these lines you don't need

    if (pass)
    {
        for (int y = rect.Top; y < rect.Bottom; y++)
        {
            if (IsCancelRequested) return;
            for (int x = rect.Left; x < rect.Right; x++)
            {
                dst[x,y] = Rectangles_Surface[x,y];
            }
        }
    }
}

Based off this working G'MIC code:

#@cli rep_rrd: eq. to 'rep_random_rectangular_division' : (+)
rep_rrd: rep_random_rectangular_division $*
#@cli rep_random_rectangular_division: split>1,_additional_thickness>=0,_max_iter>=2,_probability[%]>0,_loop_limit>1,_seed
#@cli : Generate random division of rectangle as in random number of division and varying thickness within rectangle.
#@cli : _additional_thickness refers to the excess pixel thickness.
#@cli : _max_iter limits the number of iterations per rectangle.
#@cli : _probability determines the probability that a rectangle will be permitted to be utilized for further iteration.
#@cli : _loop_limit limits the number of time the process of subdivision is done.
#@cli : _seed generates the output based on defined parameter.
#@cli : Default values: '_gen_thick=0','_max_iter=5','_probability[%]=95%','_loop_limit=5000','_seed=n/a'
rep_random_rectangular_division:
skip ${2=0},${3=5},${4=95%},${5=5000},${6=}
check "$4>0"
repeat $! l[$>]
 _rep_random_rectangular_division $*
endl done
_rep_random_rectangular_division:
skip ${2=0},${3=5},${4=95%},${5=5000},${6=}
 
r 100%,100%,1,1 #You can ignore this.
 
1,1,1,5 #Modifiable Rectangle Array
1,1,1,5 #Unmodifiable Rectangle Array
 
eval ${-math_lib}"
 if(narg($6),srand($6););
 const ww=w#-3-1; #Width of Image
 const hh=h#-3-1; #Height of Image
 const max_split=max(1,int(abs($1)));                   #Number of Split per Rectangle
 const internal_space=int(abs($2));                     #Additional paces between Split
 const test_boundary=internal_space?(internal_space+1); #Test if rectangle is acceptable to split
 const max_iter=max(2,round(abs($3)));                  #Maximum Iteration
 const odd=cut($4,0,1);                                 #Probability of splitting rectangle
 const arr_limit=round(abs($5));                        #The limit of looping to split rectangle
 
 diff_check(a)=( #diff_check(a) is a function
  mri=max_split;
  ds=a/mri;
  if(mri>1&&ds<1,
   while(mri>1&&ds<1,
    mri--;
    ds=a/mri;
   );
  );
  ds>1;
 );
 
 width_check=diff_check(ww-internal_space*2); # Determine if the width of image is reasonable with parameters assigne
 height_check=diff_check(hh-internal_space*2); # Determine if the height of image is reasonable with parameters assigne
 
 !(width_check||height_check)?run('error inv_dim'); #If neither are reasonable, then throws a error
 
 dar_insert(#-2,[0,ww,0,hh,0]);   #Insert the dimensions of image and the first iteration number which is 0 into the modifiable array
 
 sub_column(v,point)=(            #Function to Split Rectangle
  ri=int(u(1,max_split))+1;       #Number of Division
  mri=ri-1;                       #Maximum Division Iteration
  sx=v[0]+test_boundary;          #Start Point for Next Split
  ex=v[1]-test_boundary;          #End Gap between the End Index and the start of the final Split
  diff=ex-sx;                     #Difference between the Two
  bound_check=diff>test_boundary; #Check the boundary between two, if fails, send it to the un-modifiable rectangle array
  skip=0;                         #Boolean Value of skip
  dar_remove(#-2,point);          #Remove Rectangle Information at point
  if(bound_check,                 #If Bound Check
   ds=diff/mri;                   #The length of diff divided by the maximum-iteration number.
   if(mri>1&&ds<=test_boundary,   #Check if the distance is smaller than test_boundary. If fail, then send to unmodifiable rectangle array
    while(mri>1&&ds<=test_boundary, #Used to find the minimum mri to reach size greater than test_bounary
     ri--;
     mri--;
     ds=diff/mri;
    );
   );
   if(test_boundary||diff?(ds>test_boundary):1, #If condition meets, then it will modify the rectangle. Otherwise, send it to unmodifiable
    py=[v[2],v[3]];   #Two Variable inserted as one. Used for simplifying Code
    iter=v[4]+1;      #The current iteration number of rectangle plus 1. Used for stopping splitting at iteration-n
    p=v[0];           #Start at min-x of rectangle
    repeat(ri,ri_ind, #Repeat ri time, and ri_ind is the number of used as iterator
     rb=odd<1?u(0,1)>odd:0; #The probability of a rectangle will be modifiable or not
     ri_ind==mri?( #Meets the last iteration of ri loop
      if(p>v[1],
       p=v[1];
       if(!(v[3]-v[2]),rb=1;); #If the pixel dimension is equal to 1, it no longer becomes modifiable
      );
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[p,v[1],py,iter]); #Send to unmodifiable
      ):(
       dar_insert(#-2,[p,v[1],py,iter]); #Send to modifiable
      );
     ):
     !ri_ind?(
      mx=sx+ds;
      np=min(max(sx,round(u(p,mx))),ex);
      vp=[p,np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[vp,py,iter]);
      ):(
       dar_insert(#-2,[vp,py,iter]);
      );
      p=np+1;
      if(p>=ex,skip=1;);
     ):(
      if(skip,continue(););
      mx+=ds;
      np=min(max(p+internal_space,round(u(p,mx))),ex);
      vp=[min(p,ex),np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[vp,py,iter]);
      ):(
       dar_insert(#-2,[vp,py,iter]);
      );
      p=np+1;
     );
    );
   ,dar_insert(#-1,v);
   );
  ,dar_insert(#-1,v);
  );
 );
 
 sub_row(v,point)=(
  ri=int(u(1,max_split))+1;
  mri=ri-1;
  sy=v[2]+test_boundary;
  ey=v[3]-test_boundary;
  diff=ey-sy;
  bound_check=diff>test_boundary;
  skip=0;
  dar_remove(#-2,point);
  if(bound_check,
   ds=diff/mri;
   if(mri>1&&ds<=test_boundary,
    while(mri>1&&ds<=test_boundary,
     ri--;
     mri--;
     ds=diff/mri;
    );
   );
   if(test_boundary||diff?(ds>test_boundary):1,
    px=[v[0],v[1]];
    iter=v[4]+1;
    p=v[2];
    repeat(ri,ri_ind,
     rb=odd<1?u(0,1)>odd:0;
     ri_ind==mri?(
      if(p>v[3],
       p=v[3];
       if(!(v[1]-v[0]),rb=1;);
      );
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[px,p,v[3],iter]);
      ):(
       dar_insert(#-2,[px,p,v[3],iter]);
      );
     ):
     !ri_ind?(
      my=sy+ds;
      np=min(max(sy,round(u(p,my))),ey);
      vp=[p,np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[px,vp,iter]);
      ):(
       dar_insert(#-2,[px,vp,iter]);
      );
      p=np+1;
      if(p>=ey,skip=1;);
     ):(
      if(skip,continue(););
      my+=ds;
      np=min(max(p+internal_space,round(u(p,my))),ey);
      vp=[min(p,ey),np];
      (rb||(iter==max_iter))?(
       dar_insert(#-1,[px,vp,iter]);
      ):(
       dar_insert(#-2,[px,vp,iter]);
      );
      p=np+1;
     );
    );
   ,dar_insert(#-1,v);
   );
  ,dar_insert(#-1,v);
  );
 );
 
 
 v=I[#-2,0];
 
 width_check&&height_check?(
  u(0,1)<=.5?(
   sub_row(v,0);
  ):(
   sub_column(v,0);
  );
 ):
 width_check?(
  sub_column(v,0);
 ):
 height_check?(
  sub_row(v,0);
 );
 
 arr_point=0;
 
 while(dar_size(#-2),
  p_ind=int(u(dar_size(#-2)));
  cv=I[#-2,p_ind];
  u(0,1)<.5?(
   sub_row(cv,p_ind);
  ):(
   sub_column(cv,p_ind);
  );
  arr_point++;
  if(arr_point>=arr_limit,break());
 );
 
 resize(#-2,1,dar_size(#-2),1,4,0);
 resize(#-1,1,dar_size(#-1),1,4,0);"
 
a[-2,-1] y
 
eval. :"begin(
  convert2coords(c)=(
   tl=[c[0],c[2]];
   tr=[c[1],c[2]];
   bl=[c[0],c[3]];
   br=[c[1],c[3]];
   [tl,tr,br,bl];
  );
 );
 polygon(#-2,4,convert2coords(I),1,y);"
 
rm.

October 1, 2021

I haven't tested this, but if I have to wager a guess, it's because you're using multiple rules and IndirectUI doesn't address that too well.

I have that bugs in few of my plugins, I can't fix that.

October 1, 2021

After changing the writeline place, it gives non-zero value. Put it after RemoveAt(0). In spite of this, the code doesn't seem to work.

October 1, 2021

Right now, I have a near complete code.

The only problem is that DEBUG shows ModifiableRect[0] outputs (0,0,0,0,0). If that wasn't the case, then the code should work in theory.

The idea is to create array containing rectangles, and the voids modify existing rectangle and insert new array of rectangles. iter means number of iteration of splitting.

Some questions:

1. Is the binary Random condition coded in here is correct? myRandom(2)==0?

2. Any reason why it outputs a blank image?

Spoiler

// Name:
// Submenu:
// Author:
// Title:
// Version:
// Desc:
// Keywords:
// URL:
// Help:
#region UICode
IntSliderControl max_divide = 10; // [1,20] Division
IntSliderControl init_add_thick = 0; // [0,100] Additional Thickness
IntSliderControl max_iter = 5; // [2,40] Maximum Division Iteration
IntSliderControl probability = 95; // [0,100] Probability of Division(%)
IntSliderControl max_loop = 2000; // [1000,2097152] Loop Limit
DoubleSliderControl border = 10; // [0,100] Border(%)
ReseedButtonControl seed = 0; // Reseed
#endregion
#if DEBUG
#endif

int[,] Rectangles_Surface;

Random Seed = new Random();
int new_seed;

List<(int,int,int,int,int)> Modifiable_Rect = new List<(int,int,int,int,int)>{
            (0,0,0,0,0)
};

List<(int,int,int,int,int)> Unmodifiable_Rect = new List<(int,int,int,int,int)>{
            (0,0,0,0,0)
};

bool diff_check(int a)
{
    int mri = max_divide;
    double ds = (double)(a/mri);
    if (mri>1&&(ds<1)){
        while(mri>1&&(ds<1)){
            mri--;
            ds = (double)(a/mri);
        }
    }

    return ds>1;
}

void divide_column(int point,int border_size,int test_boundary,Random rand){
    int ri = rand.Next(1,max_divide)+1;
    int mri = ri-1;
    int min_x=Modifiable_Rect[point].Item1;
    int max_x=Modifiable_Rect[point].Item2;
    int min_y=Modifiable_Rect[point].Item3;
    int max_y=Modifiable_Rect[point].Item4;
    int iter=Modifiable_Rect[point].Item5 + 1;
    int sx = min_x+test_boundary;
    int ex = max_x+test_boundary;
    bool bound_check = (ex-sx)>test_boundary;
    bool skip = false;
    double mx,d_np;
    int np;
    Modifiable_Rect.RemoveAt(point);
    if(bound_check)
    {
        int diff = (ex-sx);
        double ds=(double)(diff/mri);
        if(mri>1&&(ds<=(double)(test_boundary)))
        {
            while(mri>1&&(ds<=(double)(test_boundary)))
            {
                ri--;
                mri--;
                ds=(double)(diff/mri);
            }
        }
        bool process = (test_boundary>0)||(diff>0)?(ds>(double)(test_boundary)):true;
        if (process)
        {
            int p=min_x;
            mx=(double)(p);
            for (int ri_ind= 0 ; ri_ind < ri ; ri_ind++){
                bool rb = probability<100?(rand.Next(100)>probability):false;
                if (ri_ind==mri)
                {
                    if(p>max_x){
                        p=max_x;

                        if((max_y-min_y)==0){rb=true;}

                        if (rb || iter==max_iter)
                        {
                            Modifiable_Rect.Add((p,max_x,min_y,max_y,iter));
                        }
                        else
                        {
                            Unmodifiable_Rect.Add((p,max_x,min_y,max_y,iter));

                        }
                    }
                }
                else
                {
                    if(ri_ind==0)
                    {
                        mx+=ds;
                        d_np=Math.Min(Math.Max(sx,rand.Next(p,(int)(Math.Round(mx)))),ex);
                        np=(int)(Math.Round(d_np));
                        if (rb || iter==max_iter)
                        {
                            Modifiable_Rect.Add((p,np,min_y,max_y,iter));
                        }
                        else
                        {
                            Unmodifiable_Rect.Add((p,np,min_y,max_y,iter));

                        }
                        p=np+1;
                        if(p>=ex)
                        {
                            skip = true;
                        }

                    }
                    else
                    {
                        if(skip){continue;}
                        mx+=ds;
                        d_np=Math.Min(Math.Max(p+border_size,rand.Next(p,(int)(Math.Round(mx)))),ex);
                        np=(int)(Math.Round(d_np));
                        if (rb || iter==max_iter)
                        {
                            Modifiable_Rect.Add((p,np,min_y,max_y,iter));
                        }
                        else
                        {
                            Unmodifiable_Rect.Add((p,np,min_y,max_y,iter));
                        }
                    }
                }
            }
        }
        else
        {
            Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,iter));
        }

    }
    else
    {
        Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,iter));
    }
}

void divide_row(int point,int border_size,int test_boundary,Random rand){
    int ri = rand.Next(1,max_divide)+1;
    int mri = ri-1;
    int min_x=Modifiable_Rect[point].Item1;
    int max_x=Modifiable_Rect[point].Item2;
    int min_y=Modifiable_Rect[point].Item3;
    int max_y=Modifiable_Rect[point].Item4;
    int iter=Modifiable_Rect[point].Item5 + 1;
    int sy = min_y+test_boundary;
    int ey = max_y+test_boundary;
    bool bound_check = (ey-sy)>test_boundary;
    bool skip = false;
    double my,d_np;
    int np;
    Modifiable_Rect.RemoveAt(point);
    if(bound_check)
    {
        int diff = (ey-sy);
        double ds=(double)(diff/mri);
        if(mri>1&&(ds<=(double)(test_boundary)))
        {
            while(mri>1&&(ds<=(double)(test_boundary)))
            {
                ri--;
                mri--;
                ds=(double)(diff/mri);
            }
        }
        bool process = (test_boundary>0)||(diff>0)?(ds>(double)(test_boundary)):true;
        if (process)
        {
            int p=min_y;
            my=(double)(p);
            for (int ri_ind= 0 ; ri_ind < ri ; ri_ind++){
                bool rb = probability<100?(rand.Next(100)>probability):false;
                if (ri_ind==mri)
                {
                    if(p>max_x){
                        p=max_y;

                        if((max_x-min_x)==0){rb=true;}

                        if (rb || iter==max_iter)
                        {
                            Modifiable_Rect.Add((min_x,max_x,p,max_y,iter));
                        }
                        else
                        {
                            Unmodifiable_Rect.Add((min_x,max_x,p,max_y,iter));

                        }
                    }
                }
                else
                {
                    if(ri_ind==0)
                    {
                        my+=ds;
                        d_np=Math.Min(Math.Max(sy,rand.Next(p,(int)(Math.Round(my)))),ey);
                        np=(int)(Math.Round(d_np));
                        if (rb || iter==max_iter)
                        {
                            Modifiable_Rect.Add((min_x,max_y,p,np,iter));
                        }
                        else
                        {
                            Unmodifiable_Rect.Add((min_x,max_y,p,np,iter));

                        }
                        p=np+1;
                        if(p>=ey)
                        {
                            skip = true;
                        }

                    }
                    else
                    {
                        if(skip){continue;}
                        my+=ds;
                        d_np=Math.Min(Math.Max(p+border_size,rand.Next(p,(int)(Math.Round(my)))),ey);
                        np=(int)(Math.Round(d_np));
                        if (rb || iter==max_iter)
                        {
                            Modifiable_Rect.Add((min_x,min_y,p,np,iter));
                        }
                        else
                        {
                            Unmodifiable_Rect.Add((min_x,min_y,p,np,iter));
                        }
                    }
                }
            }
        }
        else
        {
            Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,iter));
        }

    }
    else
    {
        Unmodifiable_Rect.Add((min_x,max_x,min_y,max_y,iter));
    }
}

bool pass=false;

void PreRender(Surface dst, Surface src)
{

    if (Rectangles_Surface==null){
        Rectangles_Surface=new int [src.Width,src.Height];
    }

    Random myRandom;

    if (new_seed != seed)
    {
        myRandom = Seed;
    }
    else
    {
        myRandom = new Random(int.MaxValue);
    }

    new_seed = seed;

    int width  = src.Width  - 1;
    int height = src.Height - 1;
    int border_size;
    int test_boundary;

    if (init_add_thick>0)
    {
        border_size=init_add_thick+1;
        test_boundary=border_size+1;
    }
    else{
        border_size=0;
        test_boundary=0;
    }

    bool width_check=diff_check(width-border_size*2);
    bool height_check=diff_check(height-border_size*2);

    if (width_check||height_check){
        pass = true;
        Unmodifiable_Rect.RemoveAt(0);
        Modifiable_Rect.Add((0,width,0,height,0));
        Debug.WriteLine(Modifiable_Rect[0]);
        Modifiable_Rect.RemoveAt(0);
        if (width_check&&height_check)
        {
            if(myRandom.Next(2)==0)
            {
                divide_row(0,border_size,test_boundary,myRandom);
            }
            else
            {
                divide_column(0,border_size,test_boundary,myRandom);
            }
        }
        else
        {
            if(height_check)
            {
                divide_row(0,border_size,test_boundary,myRandom);
            }
            else
            {
                divide_column(0,border_size,test_boundary,myRandom);
            }
        }
        
        int arr_point=0;
        int p_ind,sx,sy,mx,my;

        while(Modifiable_Rect.Count>0)
        {
            p_ind=myRandom.Next(Modifiable_Rect.Count-1);
            if(myRandom.Next(2)==0)
            {
                divide_row(p_ind,border_size,test_boundary,myRandom);
            }
            else
            {
                divide_column(p_ind,border_size,test_boundary,myRandom);
            }
            arr_point++;
            if(arr_point>=max_loop){break;}
        }

        if(Modifiable_Rect.Count>0){
            for(int i = 0 ; i < Modifiable_Rect.Count ; i++){
                sx = Modifiable_Rect[i].Item1;
                sy = Modifiable_Rect[i].Item2;
                mx = Modifiable_Rect[i].Item3 + 1;
                my = Modifiable_Rect[i].Item4 + 1;
                for (int x = sx ; x < mx ; x++){
                    for (int y = sy ; y < my ; y++){
                        Rectangles_Surface[x,y]=i;
                    }
                }
            }
        }
        if(Unmodifiable_Rect.Count>0){
            for(int i = 0 ; i < Unmodifiable_Rect.Count ; i++){
                sx = Unmodifiable_Rect[i].Item1;
                sy = Unmodifiable_Rect[i].Item2;
                mx = Unmodifiable_Rect[i].Item3 + 1;
                my = Unmodifiable_Rect[i].Item4 + 1;
                for (int x = sx ; x < mx ; x++){
                    for (int y = sy ; y < my ; y++){
                        Rectangles_Surface[x,y]=i;
                    }
                }
            }
        }
    }
}

void Render(Surface dst, Surface src, Rectangle rect)
{
    // Delete any of these lines you don't need
    Rectangle selection = EnvironmentParameters.SelectionBounds;
    int centerX = ((selection.Right - selection.Left) / 2) + selection.Left;
    int centerY = ((selection.Bottom - selection.Top) / 2) + selection.Top;
    ColorBgra primaryColor = EnvironmentParameters.PrimaryColor;
    ColorBgra secondaryColor = EnvironmentParameters.SecondaryColor;
    int brushWidth = (int)EnvironmentParameters.BrushWidth;
    int val;

    ColorBgra currentPixel;
    for (int y = rect.Top; y < rect.Bottom; y++)
    {
        if (IsCancelRequested) return;
        for (int x = rect.Left; x < rect.Right; x++)
        {
            currentPixel = src[x,y];
            val = Rectangles_Surface[x,y];
            dst[x,y] = ColorBgra.FromBgra((byte)(val),(byte)(val),(byte)(val),255);
        }
    }
}

October 1, 2021

EDIT: Never mind, I got it.

October 1, 2021

image.png.d5c4400435adcc7decf2a4e4f04e0154.png

September 30, 2021

2 minutes ago, toe_head2001 said:
This code works for me; no errors.
List<(int,int,int,int,int)> Image_Rect = new List<(int,int,int,int,int)>();
Image_Rect.Add((100,0,100,0,5));
Are you using an old version of Visual Studio? Like 2017, or even an old build of 2019?

CodeLab 6.3 actually.

September 30, 2021

For both, I get errors.

Invalid token '(' in class, record, struct, or interface member declaration
Type expected
Tuple must contain at least two elements.
) expected
Tuple must contain at least two elements.
) expected
Invalid token '100' in class, record, struct, or interface member declaration

September 30, 2021

Here's the problem I have. How to add to Image_Rect list?

List<(int,int,int,int,int)> Image_Rect = new List<(int,int,int,int,int)>();
Image_Rect.Add(Tuple((100,0,100,0,5)));

The above don't work.

What I'm trying to do is create 2 set of dynamic array of fixed size array of size 5, and to be able to access each variable at index n and to remove at index n. In addition to that, I would like to be able to use functions on it to replace the n index. Any idea?

September 25, 2021

New Filter! - Random Subdivision

September 21, 2021

Finally, I had refactored Fibonacci filter. Also, Fibonacci Texture has been renamed to Fibonacci. There's more features now with the Fibonacci.

September 16, 2021

I checked with git diff, and as it turns out, I resolved all possible problem. git diff is wonderful. But, I did not come here to tell you people that.

I came here to announce a new filter! Ellsworth Kelly Board

r5gqqw71orn71.png?width=600&auto=webp&s=

September 11, 2021

Some of you may noticed bugs that are cropping up. Please do not be alarmed, I'm in the process of refactoring code.

For non-programmers, this means making code easier to comprehend, and reducing reductive lines.

So, these bugs will be fixed, but I do need cooperation. If you can find bugs, do tell them to me, and they will be addressed.

September 9, 2021

First, look into plugin index.

Your best bet is to use this:

In addition to what @Pixey mentioned.

Sign In

Reptillian

Posts

Joined

Last visited

Days Won

Content Type

Profiles

Forums

Posts posted by Reptillian

How to set up IndirectUI rules: 1 Boolean, and any of three dropdown option to activate?

How to set up IndirectUI rules: 1 Boolean, and any of three dropdown option to activate?

Batch remove white BG around simple images

Reptorian's G'MIC Code Workshop

Reptorian's G'MIC Code Workshop

New packaging requirements for plugins starting with PDN 4.3 / .NET 5

New packaging requirements for plugins starting with PDN 4.3 / .NET 5

About the New subforum

Random Rectangle Division

Random Rectangle Division

How to apply the IndirectUI rules correctly?

Rectangle Division (Incompleted Code Available Here)

How to apply the IndirectUI rules correctly?

Rectangle Division (Incompleted Code Available Here)

Rectangle Division (Incompleted Code Available Here)

A question on List I was not able to find on google or maybe I'm missing something.

A question on List I was not able to find on google or maybe I'm missing something.

A question on List I was not able to find on google or maybe I'm missing something.

A question on List I was not able to find on google or maybe I'm missing something.

A question on List I was not able to find on google or maybe I'm missing something.

Reptorian's G'MIC Code Workshop

Reptorian's G'MIC Code Workshop

Reptorian's G'MIC Code Workshop

Reptorian's G'MIC Code Workshop

Photo adjustments, light temperature, luminosity, midtones, gamma...

Browse

Activity