Primfaktorisering.

Hej

 

Koden jag hade för att genomföra en Primfaktorisering utav bildstorlekar var för seg, det skapades för många små bilder vilket gjorde att enheten fick arbeta hårdare med alla dessa små målningar.

 

Nu behövde jag komma fram till en bättre algoritm för att beräkna största möjliga bildrutor, och kom fram med denna kodsnutt istället som också är skriven i C#.

 

using System;

using System.Collections;

 

namespace TestAlgorithm

{

class Program

{

class Returner

{

public int mDirection; // 0 = width, 1 = height.

public int mPartSize;

public int mPartSizeSum;

}

private static int calculateParts(float pixelSize, int bigSize)

{

int sizer = bigSize;

int smallSize = 0;

 

// Skip less than 8x8 it's too small!

while (sizer >= 8)

{

if (smallSize == 0 && sizer <= pixelSize)

smallSize = sizer;

 

// 2048, 1024, 512, 256, 128, 64, 32, 16, 8..

sizer = sizer / 2;

}

 

return smallSize;

}

static ArrayList calcImagePartSize(float scrW, float scrH)

{

ArrayList returner = new ArrayList();

 

float scrOther = scrW;

int direction = 1;

float missingPixels = scrH;

 

if (scrW <= scrH)

{

direction = 0;

missingPixels = scrW;

scrOther = scrH;

}

 

int sizePart = 2048;

int savedBigPart = 0;

bool done = false;

int stepper = 0;

 

// Firstly calculate one direction..

while (!done)

{

Returner ret = new Returner();

ret.mDirection = direction;

 

// Find biggest possible part.

// Based on the smallest width height..

sizePart = calculateParts(missingPixels, sizePart);

ret.mPartSize = sizePart;

 

// Find out how many sizers that fit..

int howManySizeParts = (int)(missingPixels / sizePart);

ret.mPartSizeSum = howManySizeParts;

 

if (sizePart != 0)

returner.Add(ret);

 

// Find out what's missing..

float decTest = (missingPixels / sizePart) - (int)(missingPixels / sizePart);

missingPixels = d+ecTest * sizePart;

 

// This first big part is common

// for both width and height..

if (savedBigPart == 0)

savedBigPart = sizePart;

 

// Skip less than 8x8 it's just too small!

if (sizePart == 8 && stepper < 1)

{

if (direction == 0)

direction = 1;

else

direction = 0;

 

Returner r = new Returner();

r.mDirection = direction;

r.mPartSize = savedBigPart;

 

// First calculate big size on next direction

// Before we continue with it..

// Find out how many that will fit..

howManySizeParts = (int)(scrOther / savedBigPart);

r.mPartSizeSum = howManySizeParts;

 

returner.Add(r);

 

// Find out what's missing..

decTest = (missingPixels / sizePart) - (int)(missingPixels / sizePart);

 

missingPixels = scrOther - (savedBigPart * howManySizeParts);

sizePart = 2048;

 

// Time for the next direction..

stepper++;

}

else if (sizePart <= 8)

done = true;

}

 

return returner;

}

 

static void Main(string[] args)

{

int scrW = 2304;

int scrH = 1080;

 

ArrayList rets = Program.calcImagePartSize(scrW, scrH);

 

for (int i=0;i<rets.Count;i++)

{

Returner ret = (Returner)rets[i];

Console.WriteLine("Dir:" + ret.mDirection + " mPartSize:" + ret.mPartSize + " mPartSizeSum:" + ret.mPartSizeSum);

}

 

Console.ReadLine();

}

}

}

 

Den här koden räknar ut alla de största möjliga delarna, great!

Här är resultatet testprogrammet skriver ut.

 

 

Dir: 1 är alltså bildstorlekarna på höjden och Dir: 0 är på bredden.

Här är också mPartSize storleken på den största möjliga primfaktor-bilden, och mPartSizeSum innehåller hur många utav dessa storlekar som ska läggas till.

Med andra ord så går det enligt utskriften 1 st 1024x1024 pixel bild på höjden medan det går 2 st på bredden o.s.v.

 

Min funktion skippar bildstorlekar som är 4x4, 2x2 samt 1x1, vilket i mitt fall inte alls har någon betydelse eftersom det är så smått och jag skapar ändå bilden efter summan av alla delbilder för att sedan centrera denna på skärmen.

Vill på alla sätt och vis undvika att spelet ska behöva rita ut onödigt många smådelar, annars är det bara att släppa på restriktionen i funktionen om någon annan vill ta koden för eget bruk.

 

Funktionen kommer köras varje gång en bild behöver uppdatera sin storlek, vilket nästan aldrig komer att inträffa. Det är altså inget som kommer att ta massor av cyklar från processorn för att genomföra gång på gång, bara en gång någon enstaka gång.

 

Jag kommer också att koppla dessa Returner objekt till bildobjekten så att mitt spel slipper göra en sökning efter bilderna mot JPCT hela tiden när de ska ritas ut, vilket kommer att gå fortare eftersom jag har upptäckt att den sökningen är långsam.

 

Det här känns riktigt bra i ögonen.

 

See you next time!