Generator dimenzija pravougaonih dvodimenzionalnih elemena

/*****************************************************************************************************

* Program name : Generator dimenzija pravougaonih dvodimenzionalnih elemenata *

* Program ver. : 3.1 Finalna verzija *

* Created by : SharpDevelop *

* Code author : Perić Željko *

* Code language : C# *

* Date created : 20.08.2013 *

* Time created : 21:22 *

* *

* *

* Program Description : Program je kreiran za potrebe testiranja programa za uklapanje *

* pravougaonih dvodimenzionalnih elemenata na ortogonalnoj tabli. *

* *

* Pravougaoni dvodimenzionalni element karakterišu 'DUŽINA' i 'ŠIRINA'. *

* Ove dve karakteristike sa svojim vrednostima se nazivaju 'DIMENZIJE'. *

* Program generiše traženi par vrednosti, za dimenzije elemenata, *

* uz pomoć programske funkcije za generisanje slučajnih brojeva. *

* Vrednosti za dužinu i širinu mogu biti različite ili iste. *

* Sam pojam dužina ne podrazumeva veću vrednost u odnosu na širinu. *

* Vrednosti su pozitivni celi brojevi deljivi brojem deset. *

* *

* *

* Opcije koje kontrolišu način generisanja dimezija su : *

* *

* 1 - 'Rotacija elementa' *

* *

* 2 - 'Kopije elemenata' *

* *

* 3 - 'Dozvoljena oscilacija dimenzija' *

* *

* *

* Prva opcija se odnosi na mogućnost da se već generisane vrednosti za *

* dužinu i širinu elementa međusobno zamene i na taj način dobije novi *

* par vrednosti koji bi bio upamćen kao dimenzije novog elementa. *

* *

* Primer : *

* *

* Element br.( dužina, širina ) *

* *

* Element 1 ( 100, 50 ) rotiranjem se dobija Element 2 ( 100, 50 ) *

* *

* *

* Kopija elementa je onaj element koji ima iste vrednosti za dužinu i *

* širinu kao i neki drugi element. *

* *

* Primer : *

* *

* Element 1 ( 100, 50 ) jeste kopija Elementa 2 ( 100, 50 ) *

* Element 1 ( 100, 50 ) nije kopija Elementa 2 ( 50, 100 ) *

* *

* Druga opcija sprečava generisanje istih vrednosti za dužinu i širinu *

* elemenata, odnosno onemogućava pojavu kopija elemenata. *

* U nekim slučajevima ova opcija je onemogućena jer zavisi od izbora *

* ostalih opcija u programu, druga i treća opcija su isključive. *

* Broj dimenzija koje se mogu generisati kada je ova opcija uključena *

* zavisi od odnosa odabranih vrednosti za opsege najmanje i najveće *

* širine i dužine elemenata i mogućnosti rotacije elemenata. *

* Ako je odnos vrednosti nepovoljan, u zadatim opsezima nije moguće *

* generisati željeni broj jedinstvenih dimenzija. *

* *

* *

* Treća opcija kontroliše razliku u dimenzijama između elemenata tako što *

* određuje maksimalnu razliku u dimenzijama, između elementa koji je već *

* generisan i elementa koji tek treba da se generiše. Na ovaj način se *

* dobijaju ujednačene dimenzija elemenata, i mnogo veći broj istih *

* dimenzija. Uključenjem treće opcije isključuje se druga opcija. *

* *

* *

* Generisane dimenzije su pored prikaza u tabeli, snimljene u tekstualnom *

* dokumentu 'Dimenzije elemenata.txt' u fascikli gde se nalazi izvršna *

* verzija programa. *

* *

* *

* Broj dimenzija elemenata koje program može da generiše u zavisnosti od *

* odabranih opcija je prikazan u polju 'Max. broj elemenata' *

* *

* *

* Notice : Dozvoljeni opsezi vrednosti za promenljive unutar programa koje korisnik sam unosi *

* preko odgovarajaćih polja grafičkog korisničkog interfejsa su međusobno zavisne: *

* *

* Polje Min Maks *

* *

* 'Broj elemenata' 1 10000 *

* *

* 'Najmanja dužina' 10 'Najveća dužina' - 10 *

* 'Najmanja širina' 10 'Najveća širina' - 10 *

* *

* 'Najveća dužina' 'Najmanja dužina' + 10 10000 *

* 'Najveća širina' 'Najmanja širina' + 10 10000 *

* *

* 'Oscilacija dužine' 0 'Najveća dužina' - 'Najmanja dužina' *

* 'Oscilacija širine' 0 'Najveća širina' - 'Najmanja širina' *

* *

* *

* *

* Sve najbolje, *

* Autor *

* *

*****************************************************************************************************/

using System;

using System.ComponentModel;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace Generator_dimenzija_pravougaonih_dvodimenzionalnih_elemenata

{

public partial class MainForm : Form

{

public MainForm()

{

InitializeComponent();

// Izbriši sadržaj tabele elemenata

Tabela_Dimenzije_Elemenata.Rows.Clear();

Tabela_Dimenzije_Elemenata.RowCount = 100;

Tabela_Dimenzije_Elemenata.Enabled = false;

}

#region - Metode 'Generiši Dimenzije', za generisanje vrednosti dimenzija -

void Generiši_Dimenzije_Bez_Kopija()

{

#region - Deklaracija i inicijalizacija promenljivih -

const string naziv_dokumenta = "Dimenzije elemenata.txt";

string linija = string.Empty;

StreamWriter snimi = new StreamWriter(naziv_dokumenta,false,Encoding.UTF8);

Random slučajan_broj = new Random();

int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

int mogući_broj_dimenzija = 0;

int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

int najveća_dužina = (int)Najveća_Dužina_Polje.Value;

int najveća_širina = (int)Najveća_Širina_Polje.Value;

int opseg_dužine = 0;

int opseg_širine = 0;

int dužina = 0;

int širina = 0;

int i = 0;

int j = 0;

int k = 0;

int brojač = 0;

int [] iste_vrednosti_oba_opsega;

int [] različite_vrednosti_opsega_dužina;

int [] različite_vrednosti_opsega_širina;

int [,] dimenzije;

int z = 0;

int d = 0;

int š = 0;

bool različito = true;

#endregion

//

// Izračunaj mogući broj jedinstvenih dimenzija elemenata,

// pri zadatim vrednostima opsega

// za najveću i najmanju vrednost dužine i širine elementa

// u zavisnosti od dozvoljene ili ne dozoljene rotacije elemenata

//

#region - Metoda -

opseg_dužine = (najveća_dužina - najmanja_dužina)/10 + 1;

opseg_širine = (najveća_širina - najmanja_širina)/10 + 1;

for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

{

for(j=najmanja_širina;j<=najveća_širina;j+=10)

{

if(i==j)

{

k++; // broj istih vrednosti dva opsega

}

}

}

i = opseg_dužine - k; // broj različitih vrednosti za opseg dužine

j = opseg_širine - k; // broj različitih vrednosti za opseg širine

//

// Mogući broj jedinstvenih dimenzija elemenata

//

// Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

{

mogući_broj_dimenzija = (k*k) + (k*i*2) + (k*j*2) + (i*j*2);

}

// Ako je rotacija elemenata ne dozvoljena

else

{

mogući_broj_dimenzija = (k*k) + (k*i) + (k*j) + (i*j);

}

dimenzije = new int[mogući_broj_dimenzija,2];

Tabela_Dimenzije_Elemenata.Rows.Clear();

Tabela_Dimenzije_Elemenata.RowCount = željeni_broj_elemenata;

#endregion

//

// Pronađi sve moguće dimenzije

// s jedinstvenim parovima vrednosti za dužinu i širinu

//

#region - Metode -

// Prvi slučaj :

// Vrednosti opsega za dužinu i širinu su potpuno različite

// Granice opsega se ne preklapaju

#region - Metoda -

if(k==0)

{

i = 0;

j = 0;

brojač = 0;

dužina = 0;

širina = 0;

for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

{

for(j=najmanja_širina;j<=najveća_širina;j+=10)

{

dužina = i;

širina = j;

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

// Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

{

// Zameni vrednosti za dužinu i širinu

dužina = j;

širina = i;

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

}

}

}

}

#endregion

// Drugi slučaj :

// Opsezi za dužinu i širinu imaju istih vrednosti

// Granice opsega se preklapaju

#region - Metoda -

else if(k>0)

{

i = 0;

j = 0;

brojač = 0;

z = k;

d = opseg_dužine - k;

š = opseg_širine - k;

dužina = 0;

širina = 0;

iste_vrednosti_oba_opsega = new int[z];

različite_vrednosti_opsega_dužina = new int[d];

različite_vrednosti_opsega_širina = new int[š];

// Uporedi vrednosti oba opsega

// i razdvoji vrednosti po određenom kriterijumu

#region - Metoda -

// Izdvoji iste vrednosti iz oba opsega

z = 0;

for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

{

for(j=najmanja_širina;j<=najveća_širina;j+=10)

{

if(i==j)

{

iste_vrednosti_oba_opsega[z] = i;

z++;

}

}

}

// Izdvoji različite vrednosti iz opsega dužine

d = 0;

for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

{

različito = true;

for(j=0;j<z;j++)

{

if(i==iste_vrednosti_oba_opsega[j])

{

različito = false;

break;

}

}

if(različito)

{

različite_vrednosti_opsega_dužina[d] = i;

d++;

}

}

// Izdvoji različite vrednosti iz opsega širine

š = 0;

for(i=najmanja_širina;i<=najveća_širina;i+=10)

{

različito = true;

for(j=0;j<z;j++)

{

if(i==iste_vrednosti_oba_opsega[j])

{

različito = false;

break;

}

}

if(različito)

{

različite_vrednosti_opsega_širina[š] = i;

š++;

}

}

#endregion

// Generiši dimenzije iz niza istih vrednosti oba opsega

#region- Metoda -

for(i=0;i<z;i++)

{

for(j=0;j<z;j++)

{

dužina = iste_vrednosti_oba_opsega[i];

širina = iste_vrednosti_oba_opsega[j];

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

}

}

#endregion

// Generiši dimenzije iz niza različitih vrednosti za opseg dužina

// i niza istih vrednosti oba opsega

#region- Metoda -

for(i=0;i<d;i++)

{

for(j=0;j<z;j++)

{

dužina = različite_vrednosti_opsega_dužina[i];

širina = iste_vrednosti_oba_opsega[j];

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

// Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

{

// Zameni vrednosti za dužinu i širinu

dužina = iste_vrednosti_oba_opsega[j];

širina = različite_vrednosti_opsega_dužina[i];

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

}

}

}

#endregion

// Generiši dimenzije iz niza različitih vrednosti za opseg širina

// i niza istih vrednosti oba opsega

#region- Metoda -

for(i=0;i<š;i++)

{

for(j=0;j<z;j++)

{

// Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

{

dužina = različite_vrednosti_opsega_širina[i];

širina = iste_vrednosti_oba_opsega[j];

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

}

// Zameni vrednosti za dužinu i širinu

dužina = iste_vrednosti_oba_opsega[j];

širina = različite_vrednosti_opsega_širina[i];

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

}

}

#endregion

// Generiši dimenzije iz niza različitih vrednosti za opseg dužina i

// niza različitih vrednosti za opseg širina

#region - Metoda -

for(i=0;i<d;i++)

{

for(j=0;j<š;j++)

{

dužina = različite_vrednosti_opsega_dužina[i];

širina = različite_vrednosti_opsega_širina[j];

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

// Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

{

// Zameni vrednosti za dužinu i širinu

dužina = različite_vrednosti_opsega_širina[j];

širina = različite_vrednosti_opsega_dužina[i];

// Upamti vrednosti za dužinu i širinu

dimenzije[brojač,0] = dužina;

dimenzije[brojač,1] = širina;

brojač++;

}

}

}

#endregion

}

#endregion

#endregion

//

// Prepiši dimenzije za željeni broj elemenata u tabelu Dimenzije Elemenata

// po slučajnom izboru elemenata

//

#region - Metoda -

dužina = 0;

širina = 0;

brojač = 0;

i = 0;

if(mogući_broj_dimenzija>željeni_broj_elemenata)

{

while(brojač<željeni_broj_elemenata)

{

i = slučajan_broj.Next(0,mogući_broj_dimenzija);

if(dimenzije[i,0]>0)

{

dužina = dimenzije[i,0];

širina = dimenzije[i,1];

Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

dimenzije[i,0] = -1;

brojač++;

}

}

}

else

{

while(brojač<željeni_broj_elemenata)

{

dužina = dimenzije[brojač,0];

širina = dimenzije[brojač,1];

Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

brojač++;

}

}

#endregion

//

// Sortiraj dimenzije na osnovu vrednosti dužine i širine elementata

//

Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

Tabela_Dimenzije_Elemenata.Sort(Column1, ListSortDirection.Descending);

Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

//

// Snimi dimenzije u fajl 'Dimenzije elemenata.txt'

//

#region - Metoda -

dužina = 0;

širina = 0;

brojač = 0;

while (brojač<Tabela_Dimenzije_Elemenata.RowCount)

{

dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

linija = dužina.ToString() + "," + širina.ToString();

snimi.WriteLine(linija);

brojač++;

}

snimi.Close();

snimi.Dispose();

#endregion

}

void Generiši_Dimenzije_Sa_Dozvoljenom_Oscilacijom_Dimenzija()

{

#region - Deklaracija i inicijalizacija promenljivih -

const string naziv_dokumenta = "Dimenzije elemenata.txt";

string linija = string.Empty;

StreamWriter snimi = new StreamWriter(naziv_dokumenta,false,Encoding.UTF8);

Random slučajan_broj = new Random();

int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

int najveća_dužina = (int)Najveća_Dužina_Polje.Value+1;

int najveća_širina = (int)Najveća_Širina_Polje.Value+1;

int dozvoljena_najmanja_dužina = najmanja_dužina;

int dozvoljena_najmanja_širina = najmanja_širina;

int dozvoljena_najveća_dužina = najveća_dužina;

int dozvoljena_najveća_širina = najveća_širina;

int željena_oscilacija_dužine = (int)Oscilacija_Dužine_Polje.Value;

int željena_oscilacija_širine = (int)Oscilacija_Širine_Polje.Value;

int brojač = 0;

int dužina = 0;

int širina = 0;

Tabela_Dimenzije_Elemenata.Rows.Clear();

Tabela_Dimenzije_Elemenata.RowCount = željeni_broj_elemenata;

#endregion

//

// Generiši dimenzije prvog elementa

//

#region - Metoda -

dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

// Vrednost mora biti deljiva brojem deset

while((dužina%10) != 0)

{

dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

}

širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

// Vrednost mora biti deljiva brojem deset

while((širina%10) != 0)

{

širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

}

Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

brojač++;

//Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

{

//Zameni i upamti vrednosti za dužinu i širinu

Tabela_Dimenzije_Elemenata[0,brojač].Value = širina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = dužina.ToString();

brojač++;

}

#endregion

//

// Generiši dimenzije ostalih elemenata

// uz primenu dozvoljene oscilacije dimenzija predhodnog elementa

//

#region - Metoda -

while (brojač<željeni_broj_elemenata)

{

if(Oscilacija_Dužine_Izbor.Checked)

{

dozvoljena_najmanja_dužina = dužina - željena_oscilacija_dužine;

if(dozvoljena_najmanja_dužina<najmanja_dužina)

{

dozvoljena_najmanja_dužina = najmanja_dužina;

}

dozvoljena_najveća_dužina = dužina + željena_oscilacija_dužine;

if(dozvoljena_najveća_dužina>najveća_dužina)

{

dozvoljena_najveća_dužina = najveća_dužina;

}

}

if(Oscilacija_Širine_Izbor.Checked)

{

dozvoljena_najmanja_širina = širina - željena_oscilacija_širine;

if(dozvoljena_najmanja_širina<najmanja_širina)

{

dozvoljena_najmanja_širina = najmanja_širina;

}

dozvoljena_najveća_širina = širina + željena_oscilacija_širine;

if(dozvoljena_najveća_širina>najveća_širina)

{

dozvoljena_najveća_širina = najveća_širina;

}

}

dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

// Vrednost mora biti deljiva brojem deset

while((dužina%10) != 0)

{

dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

}

širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

// Vrednost mora biti deljiva brojem deset

while((širina%10) != 0)

{

širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

}

Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

brojač++;

//Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked && brojač<željeni_broj_elemenata)

{

//Zameni i upamti vrednosti za dužinu i širinu

Tabela_Dimenzije_Elemenata[0,brojač].Value = širina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = dužina.ToString();

brojač++;

}

}

#endregion

//

// Sortiraj dimenzije na osnovu vrednosti dužine i širine elementata

//

Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

Tabela_Dimenzije_Elemenata.Sort(Column1, ListSortDirection.Descending);

Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

//

// Snimi dimenzije u fajl 'Dimenzije elemenata.txt'

//

#region - Metoda -

dužina = 0;

širina = 0;

brojač = 0;

while (brojač<željeni_broj_elemenata)

{

dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

linija = dužina.ToString() + "," + širina.ToString();

snimi.WriteLine(linija);

brojač++;

}

snimi.Close();

snimi.Dispose();

#endregion

}

void Generiši_Dimenzije_Bez_Ograničenja()

{

#region - Deklaracija i inicijalizacija promenljivih -

const string naziv_dokumenta = "Dimenzije elemenata.txt";

string linija = string.Empty;

StreamWriter snimi = new StreamWriter(naziv_dokumenta,false,Encoding.UTF8);

Random slučajan_broj = new Random();

int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

int najveća_dužina = (int)Najveća_Dužina_Polje.Value+1;

int najveća_širina = (int)Najveća_Širina_Polje.Value+1;

int brojač = 0;

int dužina = 0;

int širina = 0;

Tabela_Dimenzije_Elemenata.Rows.Clear();

Tabela_Dimenzije_Elemenata.RowCount = željeni_broj_elemenata;

#endregion

//

// Generiši željeni broj dimenzija elemenata

//

#region - Metoda -

while (brojač<željeni_broj_elemenata)

{

dužina = slučajan_broj.Next(najmanja_dužina,najveća_dužina);

// Vrednost mora biti deljiva brojem deset

while((dužina%10) != 0)

{

dužina = slučajan_broj.Next(najmanja_dužina,najveća_dužina);

}

širina = slučajan_broj.Next(najmanja_širina,najveća_širina);

// Vrednost mora biti deljiva brojem deset

while((širina%10) != 0)

{

širina = slučajan_broj.Next(najmanja_širina,najveća_širina);

}

Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

brojač++;

//Ako je dozvoljena rotacija elemenata

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked && brojač<željeni_broj_elemenata)

{

//Zameni i upamti vrednosti za dužinu i širinu

Tabela_Dimenzije_Elemenata[0,brojač].Value = širina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = dužina.ToString();

brojač++;

}

}

#endregion

//

// Sortiraj dimenzije na osnovu vrednosti dužine i širine elementata

//

Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

Tabela_Dimenzije_Elemenata.Sort(Column1, ListSortDirection.Descending);

Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

//

// Snimi dimenzije u fajl 'Dimenzije elemenata.txt'

//

#region - Metoda -

dužina = 0;

širina = 0;

brojač = 0;

while (brojač<Tabela_Dimenzije_Elemenata.RowCount)

{

dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

linija = dužina.ToString() + "," + širina.ToString();

snimi.WriteLine(linija);

brojač++;

}

snimi.Close();

snimi.Dispose();

#endregion

}

void Generiši_Dimenzije_Click(object sender, EventArgs e)

{

Tabela_Dimenzije_Elemenata.Enabled = true;

Generiši_Dimenzije();

}

void Generiši_Dimenzije()

{

Cursor = Cursors.WaitCursor;

if(Ne_Dozvoljene_Kopije_Elemenata_Izbor.Checked && Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled)

{

Generiši_Dimenzije_Bez_Kopija();

}

else if(Oscilacija_Dužine_Izbor.Checked || Oscilacija_Širine_Izbor.Checked)

{

Generiši_Dimenzije_Sa_Dozvoljenom_Oscilacijom_Dimenzija();

}

else

{

Generiši_Dimenzije_Bez_Ograničenja();

}

Cursor = Cursors.Default;

}

#endregion

#region - Metode za ispitivanje i sortiranje -

void Da_Li_Može_Bez_Kopija_Elemenata()

{

#region - Deklaracija i inicijalizacija promenljivih -

int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

int mogući_broj_dimenzija = 0;

int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

int najveća_dužina = (int)Najveća_Dužina_Polje.Value;

int najveća_širina = (int)Najveća_Širina_Polje.Value;

int opseg_dužine = 0;

int opseg_širine = 0;

int i = 0;

int j = 0;

int k = 0;

#endregion

//

// Izračunaj mogući broj jedinstvenih dimenzija elemenata,

// pri zadatim vrednostima opsega

// za najveću i najmanju vrednost dužine i širine elementa

// u zavisnosti od dozvoljene ili ne dozoljene rotacije elemenata

//

#region - Metoda -

opseg_dužine = (najveća_dužina - najmanja_dužina)/10 + 1;

opseg_širine = (najveća_širina - najmanja_širina)/10 + 1;

for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

{

for(j=najmanja_širina;j<=najveća_širina;j+=10)

{

if(i==j)

{

k++; // broj istih vrednosti dva opsega

}

}

}

i = opseg_dužine - k; // broj različitih vrednosti za opseg dužine

j = opseg_širine - k; // broj različitih vrednosti za opseg širine

//

// Mogući broj jedinstvenih dimenzija elemenata

//

// Ako je rotacija elemenata dozvoljena

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

{

mogući_broj_dimenzija = (k*k) + (k*i*2) + (k*j*2) + (i*j*2);

}

// Ako rotacija elemenata nije dozvoljena

else

{

mogući_broj_dimenzija = (k*k) + (k*i) + (k*j) + (i*j);

}

// Ako je izabrana opcija bez kopija

if(Ne_Dozvoljene_Kopije_Elemenata_Izbor.Checked)

{

// Ako je mogući broj jedinstvenih dimenzija elemenata

// veći od dozvoljenog maksimuma

if(mogući_broj_dimenzija>10000)

{

mogući_broj_dimenzija = 10000;

}

// Prikaži mogući broj dimenzija

Maksimalni_Broj_Elemenata_Polje.Text = mogući_broj_dimenzija.ToString();

Željeni_Broj_Elemenata_Polje.Maximum = mogući_broj_dimenzija;

}

// Ako je dozvoljeno generisati kopije

else if(Dozvoljene_Kopije_Elemenata_Izbor.Checked)

{

// Prikaži dozvoljeni maksimum broja elemenata

Maksimalni_Broj_Elemenata_Polje.Text = "10000";

Željeni_Broj_Elemenata_Polje.Maximum = 10000;

}

#endregion

}

void Tabela_Dimenzije_Elemenata_Column_Header_Click(object sender, DataGridViewCellMouseEventArgs e)

{

//

// Sortiraj dimenzije elemenata u tabeli

// suprotnim redosledom sortiranja od predhodnog

//

Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

if(Tabela_Dimenzije_Elemenata.SortOrder == SortOrder.Descending)

{

Tabela_Dimenzije_Elemenata.Sort(Tabela_Dimenzije_Elemenata.Columns[e.ColumnIndex], ListSortDirection.Ascending);

}

else

{

Tabela_Dimenzije_Elemenata.Sort(Tabela_Dimenzije_Elemenata.Columns[e.ColumnIndex], ListSortDirection.Descending);

}

Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

}

void Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje()

{

int dužina = 0;

int širina = 0;

int brojač = 0;

//Prilagodi format vrednostima u tabeli za potrebe sortiranja

while(brojač<Tabela_Dimenzije_Elemenata.RowCount)

{

dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString("00000");

Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString("00000");

brojač++;

}

}

void Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda()

{

int dužina = 0;

int širina = 0;

int brojač = 0;

//Prilagodi format vrednostima u tabeli za potrebe pregleda

brojač = 0;

while(brojač<Tabela_Dimenzije_Elemenata.RowCount)

{

dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

brojač++;

}

}

void Sortiraj_Dimenzije_Elemenata(object sender, DataGridViewSortCompareEventArgs e)

{

// Obrada događaja SortCompare,

// koji se pokreće svaki put

// kada se upoređuju vrednosti ćelija zbog sortiranja tabele.

// Sortira podatke u tabeli na osnovu odabranog redosleda,

// rastućeg ili opadajućeg, prvo upoređujući vrednosti ćelija u prvoj,

// odabranoj koloni, a zatim, ukoliko su vrednosti iste,

// upoređujući pripadajuće vrednosti dimenzija elemenata u ćelijama u drugoj koloni.

int odabrana_kolona = 0;

int druga_kolona = 0;

// Određuje koja kolona se prvo sortira

odabrana_kolona = e.Column.Index;

// Određuje koja kolona se alternativno sortira

if(odabrana_kolona == 0)

druga_kolona = 1;

else

druga_kolona = 0;

// Upoređuje i sortira vrednosti ćelija u prvoj, odabranoj, koloni

e.SortResult = System.String.Compare(

Tabela_Dimenzije_Elemenata.Rows[e.RowIndex1].Cells[odabrana_kolona].Value.ToString(),

Tabela_Dimenzije_Elemenata.Rows[e.RowIndex2].Cells[odabrana_kolona].Value.ToString());

// Ako su upoređene vrednosti u prvoj koloni iste

// uporedi vrednosti u drugoj koloni

if (e.SortResult == 0)

{

e.SortResult = System.String.Compare(

Tabela_Dimenzije_Elemenata.Rows[e.RowIndex1].Cells[druga_kolona].Value.ToString(),

Tabela_Dimenzije_Elemenata.Rows[e.RowIndex2].Cells[druga_kolona].Value.ToString());

}

e.Handled = true;

}

#endregion

#region - Obrada događaja 'Promena izbora opcija' -

void Oscilacija_Dužine_Izbor_Promenjen(object sender, EventArgs e)

{

if(Oscilacija_Dužine_Izbor.Checked)

{

Oscilacija_Dužine_Polje.Enabled = true;

Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = false;

Dozvoljene_Kopije_Elemenata_Izbor.Checked = true;

}

else

{

Oscilacija_Dužine_Polje.Enabled = false;

if(!Oscilacija_Širine_Izbor.Checked)

{

Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = true;

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

}

void Oscilacija_Širine_Izbor_Promenjen(object sender, EventArgs e)

{

if(Oscilacija_Širine_Izbor.Checked)

{

Oscilacija_Širine_Polje.Enabled = true;

Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = false;

Dozvoljene_Kopije_Elemenata_Izbor.Checked = true;

}

else

{

Oscilacija_Širine_Polje.Enabled = false;

if(!Oscilacija_Dužine_Izbor.Checked)

{

Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = true;

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

}

void Dozvoljene_Kopije_Elemenata_Izbor_Promenjen(object sender, EventArgs e)

{

if(Dozvoljene_Kopije_Elemenata_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Ne_Dozvoljene_Kopije_Elemenata_Izbor_Promenjen(object sender, EventArgs e)

{

if(Ne_Dozvoljene_Kopije_Elemenata_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Dozvoljena_Rotacija_Elementa_Izbor_Promenjen(object sender, EventArgs e)

{

if(Dozvoljena_Rotacija_Elementa_Izbor.Checked &&

!Oscilacija_Dužine_Izbor.Checked &&

!Oscilacija_Širine_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Ne_Dozvoljena_Rotacija_Elemenata_Izbor_Promenjen(object sender, EventArgs e)

{

if(Ne_Dozvoljena_Rotacija_Elemenata_Izbor.Checked &&

!Oscilacija_Dužine_Izbor.Checked &&

!Oscilacija_Širine_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

#endregion

#region - Obrada događaja 'Promena ulaznih vrednosti' -

void Željeni_Broj_Elemenata_Polje_Promena(object sender, EventArgs e)

{

if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Najmanja_Dužina_Polje_Promena(object sender, EventArgs e)

{

if(Najmanja_Dužina_Polje.Value%10!=0)

{

MessageBox.Show(" Poslednja cifra unetog broja mora biti nula. \n" +

" npr. 10 , 50 , 100 , 110 , 250 , 600 , ... ",

" Greška pri unosu podataka !",

MessageBoxButtons.OK,

MessageBoxIcon.Error);

Najmanja_Dužina_Polje.Value = Najmanja_Dužina_Polje.Minimum;

}

else

{

Najveća_Dužina_Polje.Minimum = Najmanja_Dužina_Polje.Value + 10;

Oscilacija_Dužine_Polje.Maximum = Najveća_Dužina_Polje.Value - Najmanja_Dužina_Polje.Value;

}

if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Najveća_Dužina_Polje_Promena(object sender, EventArgs e)

{

if(Najveća_Dužina_Polje.Value%10!=0)

{

MessageBox.Show(" Poslednja cifra unetog broja mora biti nula. \n" +

" npr. 10 , 50 , 100 , 110 , 250 , 600 , ... ",

" Greška pri unosu podataka !",

MessageBoxButtons.OK,

MessageBoxIcon.Error);

Najveća_Dužina_Polje.Value = Najveća_Dužina_Polje.Maximum;

}

else

{

Najmanja_Dužina_Polje.Maximum = Najveća_Dužina_Polje.Value - 10;

Oscilacija_Dužine_Polje.Maximum = Najveća_Dužina_Polje.Value - Najmanja_Dužina_Polje.Value;

}

if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Najmanja_Širina_Polje_Promena(object sender, EventArgs e)

{

if(Najmanja_Širina_Polje.Value%10!=0)

{

MessageBox.Show(" Poslednja cifra unetog broja mora biti nula. \n" +

" npr. 10 , 50 , 100 , 110 , 250 , 600 , ... ",

" Greška pri unosu podataka !",

MessageBoxButtons.OK,

MessageBoxIcon.Error);

Najmanja_Širina_Polje.Value = Najmanja_Širina_Polje.Minimum;

}

else

{

Najveća_Širina_Polje.Minimum = Najmanja_Širina_Polje.Value + 10;

Oscilacija_Širine_Polje.Maximum = Najveća_Širina_Polje.Value - Najmanja_Širina_Polje.Value;

}

if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Najveća_Širina_Polje_Promena(object sender, EventArgs e)

{

if(Najveća_Širina_Polje.Value%10!=0)

{

MessageBox.Show(" Poslednja cifra unetog broja mora biti nula. \n" +

" npr. 10 , 50 , 100 , 110 , 250 , 600 , ... ",

" Greška pri unosu podataka !",

MessageBoxButtons.OK,

MessageBoxIcon.Error);

Najveća_Širina_Polje.Value = Najveća_Širina_Polje.Maximum;

}

else

{

Najmanja_Širina_Polje.Maximum = Najveća_Širina_Polje.Value - 10;

Oscilacija_Širine_Polje.Maximum = Najveća_Širina_Polje.Value - Najmanja_Širina_Polje.Value;

}

if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

{

Da_Li_Može_Bez_Kopija_Elemenata();

}

}

void Oscilacija_Dužine_Polje_Promena(object sender, EventArgs e)

{

if(Oscilacija_Dužine_Polje.Value%10!=0)

{

MessageBox.Show(" Poslednja cifra unetog broja mora biti nula. \n" +

" npr. 10 , 50 , 100 , 110 , 250 , 600 , ... ",

" Greška pri unosu podataka !",

MessageBoxButtons.OK,

MessageBoxIcon.Error);

Oscilacija_Dužine_Polje.Value = Oscilacija_Dužine_Polje.Minimum;

}

}

void Oscilacija_Širine_Polje_Promena(object sender, EventArgs e)

{

if(Oscilacija_Širine_Polje.Value%10!=0)

{

MessageBox.Show(" Poslednja cifra unetog broja mora biti nula. \n" +

" npr. 10 , 50 , 100 , 110 , 250 , 600 , ... ",

" Greška pri unosu podataka !",

MessageBoxButtons.OK,

MessageBoxIcon.Error);

Oscilacija_Širine_Polje.Value = Oscilacija_Širine_Polje.Minimum;

}

}

#endregion

#region - Obrada događaja 'Zahtev za pomoć' -

void Isključi_Pomoć(object sender, EventArgs e)

{

toolTip1.Active = false;

}

void Željeni_Broj_Elemenata_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Broj elemenata";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Polje 'Broj elemenata' je namenjeno,\n" +

"za izbor željenog broja elemenata,\n" +

"za koje treba generisati dimenzije.\n",

Željeni_Broj_Elemenata_Polje,0,0);

}

void Maksimalni_Broj_Elemenata_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Maksimalan broj elemenata";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Polje 'Maksimalan broj elemenata' je namenjeno,\n" +

"za prikaz maksimalnog broja elemenata,\n" +

"za koje generator može da generiše dimenzije.\n",

Maksimalni_Broj_Elemenata_Polje,0,0);

}

void Najmanja_Dužina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Najmanja dužina";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Polje 'Najmanja dužina' je namenjeno,\n" +

"za izbor najmanje dužine elementa,\n" +

"koju generator sme da generiše.\n",

Najmanja_Dužina_Polje,0,0);

}

void Najmanja_Širina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Najmanja širina";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Polje 'Najmanja širina' je namenjeno,\n" +

"za izbor najmanje širine elementa,\n" +

"koju generator sme da generiše.\n",

Najmanja_Širina_Polje,0,0);

}

void Najveća_Dužina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Najveća dužina";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Polje 'Najveća dužina' je namenjeno,\n" +

"za izbor najveće dužine elementa,\n" +

"koju generator sme da generiše.\n",

Najveća_Dužina_Polje,0,0);

}

void Najveća_Širina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Najveća širina";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Polje 'Najveća širina' je namenjeno,\n" +

"za izbor najveće širine elementa,\n" +

"koju generator sme da generiše.\n",

Najveća_Širina_Polje,0,0);

}

void Dozvoljena_Rotacija_Elementa_Izbor_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Rotacija elemenata";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Opcija 'Rotacija elemenata' omogućava da se već generisane vrednosti za ,\n" +

"dužinu i širinu elementa međusobno zamene i na taj način dobije novi ,\n" +

"par vrednosti koji bi bio upamćen kao dimenzije novog elementa.\n",

Dozvoljena_Rotacija_Elementa_Izbor,0,0);

}

void Dozvoljene_Kopije_Elemenata_Izbor_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Kopije elemenata";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Opcija 'Kopije elemenata' kontroliše generisanje\n" +

"istih vrednosti za dužinu i širinu elemenata,\n" +

"odnosno pojavu kopija elemenata.\n",

Dozvoljene_Kopije_Elemenata_Izbor,0,0);

}

void Oscilacija_Dužine_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Dozvoljena oscilacija dimenzija";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Opcija 'Dozvoljena oscilacija dimenzija'\n" +

"kontroliše razliku u dimenzijama između elemenata tako što\n" +

"određuje maksimalnu razliku u dimenzijama, između elementa koji je već\n" +

"generisan i elementa koji tek treba da se generiše. Na ovaj način se\n" +

"dobijaju ujednačene dimenzije elemenata, i mnogo veći broj istih dimenzija\n",

Oscilacija_Dužine_Polje,0,0);

}

void Generiši_Dimenzije_Dugme_Help(object sender, HelpEventArgs hlpevent)

{

toolTip1.Active = true;

toolTip1.ToolTipTitle = " Generiši";

toolTip1.ToolTipIcon = ToolTipIcon.Info;

toolTip1.Show("Klikni da bi pokrenuo generator.\n",

Generiši_Dimenzije_Dugme,70,-70);

}

#endregion

}

}

/************************************************************************

* Program Licence : *

* *

* Copyright 2013 , Perić Željko *

* (periczeljkosmederevo@yahoo.com) *

* *

* According to it's main purpose , this program is licensed *

* under the therms of 'Free Software' licence agreement. *

* *

* If You do not know what those therms applies to *

* please read explanation at the following link : *

* (http://www.gnu.org/philosophy/free-sw.html.en) *

* *

* Since it is Free Software this program has no warranty of any kind. *

************************************************************************

* Ethical Notice : *

* *

* It is not ethical to change program code signed by it's author *

* and then to redistribute it under the same author name , *

* especially if it is incorrect. *

* *

* It is recommended that if You make improvement in program code , *

* to make remarks of it and then to sign it with Your own name , *

* for further redistribution as new major version of program. *

* *

* Author name and references of old program code version should be *

* kept , for tracking history of program development. *

* *

* For any further information please contact code author at his email. *

************************************************************************/

/************************************

* List Of Revisions *

************************************

* Major revision of version 2.0 *

* Perić Željko 20.02.2014 *

* new comments *

* new options *

* help function *

* sort function changed *

* spelling checked *

* New version number 3.0 *

************************************/

/************************************

* List Of Revisions *

************************************

* Minor revision of version 3.0 *

* Perić Željko 09.12.2015 *

* new comments *

* sort methods changed *

* spelling checked *

* New version number 3.1 *

************************************/