static Polylines make_gyroid_waves(double gridZ, double density_adjusted, double line_spacing, double width, double height)
{
const double scaleFactor = scale_(line_spacing) / density_adjusted;
//scale factor for 5% : 8 712 388
// 1z = 10^-6 mm ?
const double z = gridZ / scaleFactor;
const double z_sin = sin(z);
const double z_cos = cos(z);
bool vertical = (std::abs(z_sin) <= std::abs(z_cos));
double lower_bound = 0.;
double upper_bound = height;
bool flip = true;
if (vertical) {
flip = false;
lower_bound = -M_PI;
upper_bound = width - M_PI_2;
std::swap(width,height);
}
std::vector<Vec2d> one_period = make_one_period(width, scaleFactor, z_cos, z_sin, vertical, flip); // creates one period of the waves, so it doesn't have to be recalculated all the time
Polylines result;
for (double y0 = lower_bound; y0 < upper_bound+EPSILON; y0 += 2*M_PI) // creates odd polylines
result.emplace_back(make_wave(one_period, width, height, y0, scaleFactor, z_cos, z_sin, vertical));
flip = !flip; // even polylines are a bit shifted
one_period = make_one_period(width, scaleFactor, z_cos, z_sin, vertical, flip); // updates the one period sample
for (double y0 = lower_bound + M_PI; y0 < upper_bound+EPSILON; y0 += 2*M_PI) // creates even polylines
result.emplace_back(make_wave(one_period, width, height, y0, scaleFactor, z_cos, z_sin, vertical));
return result;
}
pos_t *build_pos_list(void)
{
pos_list = (pos_t*)malloc(sizeof(pos_t) * num_nodes);
if(!strcmp(shape_name, "random")) return make_random();
if(!strcmp(shape_name, "wave")) return make_wave();
if(!strcmp(shape_name, "grid")) return make_grid();
printf("Unknown shape: %s!\n", shape_name);
exit(3);
}
void SPARSE::find_sep(long p, long& ap, long* S, long** fl, long** fr, long* TMP){
#else
void SPARSE::find_sep(long p, long* n, long& in, long& ap, long* S, long** fl, long** fr){
#endif
const long min_num = 6;//Jestli je v poli mene prvku nez min_num, budou vrcholy zapsany do P
const long min_nw = 6;//Jestli pri prochazeni je mene nez min_nw, tak uz pulku dal neprochazej
const long sf = 3;//Zadej kdyz najdes vlnu z druhe strany
const long ct = 2;//Jeste jsem nenarazil na zadnou vlnu
long str = 1;//Zadej pri vyhledavani stredu - zadava se pri pruchodu zprava
long stl = -1;//Zadej pri vyhledavani stredu - zadava se pri pruchodu zleva
long nvl[2];// pocet hodnot zleva
long nvr[2];// pocet hodnot zprava
long a = 0;// index fl a fr do kterych se zapisuje
long b = 1;// index fl a fr ze kterych se cte(byli ziskany v minule vlne)
long rv[2];// Do tohoto pole budou zapsany vystupni vrcholy z find_edges()
long nv;//number of vertices - pocet hodnot ktere jsou v casti, ktera zacina v iv
long nw;//number of waves - kolik vln se vytvorilo
long i;//obecny index
#ifdef RECURSIVE_PERMUTATION
long in=0;//Pocet rozpuleni
#endif
//===================================
//Najdi krajni "nejvzdalenejsi" vrcholy
//===================================
nv = find_edges(fl, TMP, p, S, rv, nw);
if(nv<=min_num || nw<= min_nw){
for(i=0; i<nv; i++){
P[TMP[i]] = ap--;
S[TMP[i]] = 3;
}
return;
}
//===================================
//Rozdeleni casti
//===================================
//Inicializace:
nvl[a] = 0;
nvl[b] = 1;
nvr[a] = 0;
nvr[b] = 1;
fl[b][0]= rv[0];//nalezene prvky
fr[b][0]= rv[1];
S[fl[b][0]] = stl;
S[fr[b][0]] = str;
//Hlavni smycka - pracuje dokud jsou ve vlne nalezeny nove vrcholy
//POSLI NAPROTI SOBE DVE VLNY
while(nvl[b]>0 || nvr[b]>0){
nvl[a] = make_wave(S, ap, fl[b], fl[a], nvl[b], stl, sf, ct);
nvr[a] = make_wave(S, ap, fr[b], fr[a], nvr[b], str, sf, ct);
//Zamen pole
swap(a,b);
nvl[a]=nvr[a]=0;
}
//ZJISTI JESTLI NEKTERA Z HODNOT NEZUSTALA VE SLEPE ULICCE, JESTLI ANO, OZNAC JI JAKO STRED
for(i=0;i<nv;i++){
if(fabs(S[TMP[i]]) == ct){
S[TMP[i]] = sf;
P[TMP[i]] = ap--;
}
}
//Po nalezeni dalsich polovin zavolej na kazdou polovinu pulici funkci
in = 2;
#ifdef RECURSIVE_PERMUTATION
for(i=in-1; i>-1; i--){
find_sep(rv[i],ap,S,fl,fr,TMP);
}
#endif
}
// ==============================================================================
/**
\brief Procedura - Zprehazi sloupce a radky podle permutace MTX::P
*/
void SPARSE::apply_permutation()
{
long i,j;
size_t s;//velikost pole pro kopirovani pomoci memcpy
long** new_col_start;
long* new_value_length;
double** new_val_start;
long* key = new long[row_number];//Klic podle ktereho se spravne seradi radek
//===================================
//Zamen sloupce
//===================================
for(i=0;i<row_number;i++){
for(j=0;j<value_length[i];j++){
key[j] = P[column_start[i][j]];
}
s = sizeof(long)*value_length[i];
memcpy(column_start[i],key,s);
}
//===================================
//Prohazej radky
//===================================
//Alokuj nove pole pointeru na zacatky radku
new_col_start = new long* [row_number];
new_val_start = new double* [row_number];
new_value_length = new long [row_number];
//zapis do nich prepermutovane zacatky radku
for(i=0; i<row_number; i++){
new_col_start[P[i]] = column_start[i];
new_val_start[P[i]] = value_start[i];
new_value_length[P[i]] = value_length[i];
}
//Smaz stare zacatky
delete[] value_start;
delete[] column_start;
delete[] value_length;
// //Prehazej nove vytvorene na spravna mista
value_start = new_val_start;
column_start = new_col_start;
value_length = new_value_length;
//===================================
//Setrid hodnoty v radku podle sloupce
//===================================
for(i=0;i<row_number;i++){
BB_sortl(value_length[i],column_start[i], key);
update_field_D_by_key(value_length[i],value_start[i],key);
for(j=0;j<value_length[i];j++)
if(column_start[i][j]==i)
diagonal[i]=&value_start[i][j];
}
delete[] key;
}
