This gives you an idea of how I work. Every operation is the result of hundreds lines of code, but the logic is pretty simple. We have a quasiperiodic cristal made of triangles and we detect regular shapes (squares, diamonds, octogons, 6-gons, etc.). This creates a pattern that’s later gonna be made of little glass pieces.
A paper model with “scanned” and calculated colors for the blue sky behind…
Below, the left one simulates a cloudy sky, the right one the blue sky
This is the design made by something like 5000 lines of code in Python 2.7 ;)
Some pictures of my recent attemps at solving drawing problems that I left behind a year and 1/2 ago.
CLICK ON THE PICTURE TO ZOOM
done!
I decided to change my system of titles.
Since the D65 studies start to have several pieces for each number (n°5.1, 5.2… 6.1, 6.2…) there will be a series number, refering to the type of research (or the ‘family’,) and a serial number starting with a sharp ‘#’
series 5 #2:
– I avoided most pencil traces
– Done in one week (absolute speed record, thanks to computer programming)
– Two new pigments: DPP Red (PR 254), and a Gofun-based Japanese Magenta from here: gofun
Maybe my most beautiful piece so far (?)
CLICK ON THIS PICTURE TO ZOOM AND SEE
CLICK ON THE PICTURES TO ZOOM
Working a lot those days, I’m about to reach the half of this piece. A 3rd one will follow.
CLICK ON THE PICTURES TO ZOOM, PLEASE.
When I see these photos I understand immediately that my future work will be about installing color fields in space, it’s really interesting to have a continuous gradient cut by borders like on these pics.
CLICK ON THE PICTURES TO ZOOM!
3 particular convergence points where a given amount of a color on the white paper has a reflectance of 50% (means half the luminous power of the incoming light is reflected in the direction of the eye…)
It feels exactly like pinning strings on a rigid cardboard, but it’s all linear algebra…
click on the picture to zoom, and compare with that:
https://adrienlucca.files.wordpress.com/2013/06/adrien-lucca-d65-5-8-june-13-coupe.jpg
………tired!
This thing (computationnal Geometry) will hopefully make my work much easier, faster, more precise, help avoiding lots of human mistakes, etc. However it’s a hell to computer-program when being almost totally ignorant, I’m just using the programmaing language as a linear calculator instead of being smart and properly code… I know, I’m a bullshit programmer, I know I should use classes since I use systematically similar objects such as lines, segments, intersections, colors…
And YES I know it’s an absolutely ugly code, sorry!
So, here’s the trash!
(that however fully works for triangular shapes now, after 4 full days of solving every mathematical detail:)
#include <vector>
#include <cmath>
#include <iostream>
#include <fstream>
#include <algorithm>
using namespace std;
#define PI 3.14159265
//___________________________________________________
/// variables from the *.srgb file
double xa = 0;
double ya = 0;
double Ta = 0;
double Ca = 0;
double Ma = 0;
double Da = 0;
double xb = 0;
double yb = 0;
double Tb = 0;
double Cb = 0;
double Mb = 0;
double Db = 0;
double xc = 0;
double yc = 0;
double Tc = 0;
double Cc = 0;
double Mc = 0;
double Dc = 0;
double xd = 0;
double yd = 0;
double Td = 0;
double Cd = 0;
double Md = 0;
double Dd = 0;
/// variables for calculation
double Dxa = 0; /// Deltas
double Dya = 0;
double Dxb = 0;
double Dyb = 0;
double DET = 0; /// Determinant
double Dx = 0; /// Slopes
double Mx = 0;
double Cx = 0;
double Tx = 0;
double Dy = 0;
double My = 0;
double Cy = 0;
double Ty = 0;
double points = 0; /// amount of points
//__________________________________________________
int trash = 0; // ifstream bug (?) stuff
//___________________________________
int main() {
/// FAIRE MIEUX L'IMPORTATION POUR ACCEPTER UN TABLEAU .CSV SEPARE PAR TAB ///
ifstream ifs ("mat.srgb"); ///LOADING
if (!ifs)
// process error
ifs >> trash;
ifs >> xa ;
ifs >> ya ;
ifs >> Da ;
ifs >> Ma ;
ifs >> Ca ;
ifs >> Ta ;
ifs >> xb ;
ifs >> yb ;
ifs >> Db ;
ifs >> Mb ;
ifs >> Cb ;
ifs >> Tb ;
ifs >> xc ;
ifs >> yc ;
ifs >> Dc ;
ifs >> Mc ;
ifs >> Cc ;
ifs >> Tc ;
ifs >> xd ;
ifs >> yd ;
ifs >> Dd ;
ifs >> Md ;
ifs >> Cd ;
ifs >> Td ;
if (xd == 0, yd == 0) {
points = 3;
}
else {
points = 4;
}
cout << "point A:" << endl;
cout << "x: " << xa << endl << "y: " << ya << endl << "TOP: " << Ta << " CHEESE: " << Ca << " MEAT: " << Ma << " DOWN: " << Da << endl;
cout << "point B:" << endl;
cout << "x: " << xb << endl << "y: " << yb << endl << "TOP: " << Tb << " CHEESE: " << Cb << " MEAT: " << Mb << " DOWN: " << Db << endl;
cout << "point C:" << endl;
cout << "x: " << xc << endl << "y: " << yc << endl << "TOP: " << Tc << " CHEESE: " << Cc << " MEAT: " << Mc << " DOWN: " << Dc << endl;
if (points == 4) {
cout << "point D:" << endl;
cout << "x: " << xd << endl << "y: " << yd << endl << "TOP: " << Td << " CHEESE: " << Cd << " MEAT: " << Md << " DOWN: " << Dd << endl;
}
//_________________________________________________________________________________________________________________________________________________
/// calculations
// deltas
Dxa = xa - xc;
Dya = ya - yc;
Dxb = xb - xc;
Dyb = yb - yc;
// determinant
DET = Dxa*Dyb - Dxb*Dya;
// slopes
Dx = ((Da - Dc) * Dyb - (Db - Dc) * Dya) / DET;
Mx = ((Ma - Mc) * Dyb - (Mb - Mc) * Dya) / DET;
Cx = ((Ca - Cc) * Dyb - (Cb - Cc) * Dya) / DET;
Tx = ((Ta - Tc) * Dyb - (Tb - Tc) * Dya) / DET;
Dy = ((Db - Dc) * Dxa - (Da - Dc) * Dxb) / DET;
My = ((Mb - Mc) * Dxa - (Ma - Mc) * Dxb) / DET;
Cy = ((Cb - Cc) * Dxa - (Ca - Cc) * Dxb) / DET;
Ty = ((Tb - Tc) * Dxa - (Ta - Tc) * Dxb) / DET;
// ___________________________________________________
/// frame
double MinX = 0;
double MaxX = 0;
double MinZ = 0;
double MaxZ = 0;
MinX = min(xa,xb);
MinX = min(xc,MinX);
MaxX = max(xa,xb);
MaxX = max(xc,MaxX);
MinZ = min(ya,yb);
MinZ = min(yc,MinZ);
MaxZ = max(ya,yb);
MaxZ = max(yc,MaxZ);
if (points == 4) {
MinX = min(xd,MinX);
MaxX = max(xd,MaxX);
MinZ = min(yd,MinZ);
MaxZ = max(yd,MaxZ);
}
cout << "minX, maxX, minZ, maxZ" << endl;
cout << MinX << endl;
cout << MaxX << endl;
cout << MinZ << endl;
cout << MaxZ << endl;
//_________________________________________________
/// Min & Max Densities
double MeatDmax = 0;
double MeatDmin = 0;
double CheeseDmax = 0;
double CheeseDmin = 0;
MeatDmin = min(Ma,Mb);
MeatDmin = min(Mc,MeatDmin);
MeatDmax = max(Ma,Mb);
MeatDmax = max(Mc,MeatDmax);
CheeseDmin = min(Ca,Cb);
CheeseDmin = min(Cc,CheeseDmin);
CheeseDmax = max(Ca,Cb);
CheeseDmax = max(Cc,CheeseDmax);
if (points == 4) {
MeatDmin = min(Md,MeatDmin);
MeatDmax = max(Md,MeatDmax);
CheeseDmin = min(Cd,CheeseDmin);
CheeseDmax = max(Cd,CheeseDmax);
}
bool isA = false;
bool isB = false;
bool isC = false;
bool isD = false;
bool cisA = false;
bool cisB = false;
bool cisC = false;
bool cisD = false;
bool ISA = false;
bool ISB = false;
bool ISC = false;
bool ISD = false;
bool cISA = false;
bool cISB = false;
bool cISC = false;
bool cISD = false;
/// MAX
// MEAT
if (MeatDmax == Ma) {
ISA = true;
cout << "MAX MEAT is point A" << endl;
}
else if (MeatDmax == Mb) {
ISB = true;
cout << "MAX MEAT is point B" << endl;
}
else if (MeatDmax == Mc) {
ISC = true;
cout << "MAX MEAT is point C" << endl;
}
else {
ISD = true;
cout << "MAX MEAT is point D" << endl;
}
// CHEESE
if (CheeseDmax == Ca) {
cISA = true;
cout << "MAX CHEESE is point A" << endl;
}
else if (CheeseDmax == Cb) {
cISB = true;
cout << "MAX CHEESE is point B" << endl;
}
else if (CheeseDmax == Cc) {
cISC = true;
cout << "MAX CHEESE is point C" << endl;
}
else {
cISD = true;
cout << "MAX CHEESE is point D" << endl;
}
/// MIN
// MEAT
if (ISA == true) {
if (Mb == Mc) {
isB = true;
isC = true;
}
else if (Mb == Md) {
isB = true;
isD = true;
}
else if (Mc == Md) {
isC = true;
isD = true;
}
else if (MeatDmin == Mb) {
isB = true;
}
else if (MeatDmin == Mc) {
isC = true;
}
else if (MeatDmin == Md) {
isD = true;
}
}
if (ISB == true) {
if (Ma == Mc) {
isA = true;
isC = true;
}
else if (Ma == Md) {
isA = true;
isD = true;
}
else if (Mc == Md) {
isC = true;
isD = true;
}
else if (MeatDmin == Ma) {
isA = true;
}
else if (MeatDmin == Mc) {
isC = true;
}
else if (MeatDmin == Md) {
isD = true;
}
}
if (ISC == true) {
if (Mb == Ma) {
isB = true;
isA = true;
}
else if (Mb == Md) {
isB = true;
isD = true;
}
else if (Ma == Md) {
isA = true;
isD = true;
}
else if (MeatDmin == Mb) {
isB = true;
}
else if (MeatDmin == Ma) {
isA = true;
}
else if (MeatDmin == Md) {
isD = true;
}
}
if (ISD == true) {
if (Mb == Mc) {
isB = true;
isC = true;
}
else if (Mb == Ma) {
isB = true;
isA = true;
}
else if (Mc == Ma) {
isC = true;
isA = true;
}
else if (MeatDmin == Mb) {
isB = true;
}
else if (MeatDmin == Mc) {
isC = true;
}
else if (MeatDmin == Ma) {
isA = true;
}
}
// CHEESE
if (cISA == true) {
if (Cb == Cc) {
cisB = true;
cisC = true;
}
else if (Cb == Cd) {
cisB = true;
cisD = true;
}
else if (Cc == Cd) {
cisC = true;
cisD = true;
}
else if (CheeseDmin == Cb) {
cisB = true;
}
else if (CheeseDmin == Cc) {
cisC = true;
}
else if (CheeseDmin == Cd) {
cisD = true;
}
}
if (cISB == true) {
if (Ca == Cc) {
cisA = true;
cisC = true;
}
else if (Ca == Cd) {
cisA = true;
cisD = true;
}
else if (Cc == Cd) {
cisC = true;
cisD = true;
}
else if (CheeseDmin == Ca) {
cisA = true;
}
else if (CheeseDmin == Cc) {
cisC = true;
}
else if (CheeseDmin == Cd) {
cisD = true;
}
}
if (cISC == true) {
if (Cb == Ca) {
cisB = true;
cisA = true;
}
else if (Cb == Cd) {
cisB = true;
cisD = true;
}
else if (Ca == Cd) {
cisA = true;
cisD = true;
}
else if (CheeseDmin == Cb) {
cisB = true;
}
else if (CheeseDmin == Ca) {
cisA = true;
}
else if (CheeseDmin == Cd) {
cisD = true;
}
}
if (cISD == true) {
if (Cb == Cc) {
cisB = true;
cisC = true;
}
else if (Cb == Ca) {
cisB = true;
cisA = true;
}
else if (Cc == Ca) {
cisC = true;
cisA = true;
}
else if (CheeseDmin == Cb) {
cisB = true;
}
else if (CheeseDmin == Cc) {
cisC = true;
}
else if (CheeseDmin == Ca) {
cisA = true;
}
}
/// RECAPITULATION
cout << endl << "recapitulation:" << endl;
cout << "ISA: " << ISA << " ISB: " << ISB << " ISC: " << ISC << " ISD: " << ISD << endl;
cout << "isA: " << isA << " isB: " << isB << " isC: " << isC << " isD: " << isD << endl;
cout << "cISA: " << cISA << " cISB: " << cISB << " cISC: " << cISC << " cISD: " << cISD << endl;
cout << "cisA: " << cisA << " cisB: " << cisB << " cisC: " << cisC << " cisD: " << cisD << endl;
//___________________________________________________________________________________________________
// solutions variables
double X = 0;
double Z = 0;
double D = 0;
double M = 0;
double C = 0;
double T = 0;
double A_RealMeatMax = 0;
double B_RealMeatMax = 0;
double A_RealMeatMin = 0;
double B_RealMeatMin = 0;
double A_RealCheeseMax = 0;
double B_RealCheeseMax = 0;
double A_RealCheeseMin = 0;
double B_RealCheeseMin = 0;
/// MAKE THE FIGURE BORDER'S EQUATIONS
/// equations
double EligneA_m = 0;
double EligneA_E = 0;
double EligneB_m = 0;
double EligneB_E = 0;
double EligneC_m = 0;
double EligneC_E = 0;
double MinX_linA = 0;
double MaxX_linA = 0;
double MinX_linB = 0;
double MaxX_linB = 0;
double MinX_linC = 0;
double MaxX_linC = 0;
double EligneD_m = 0;
double EligneD_E = 0;
double MinX_linD = 0;
double MaxX_linD = 0;
// m & E
if (points == 3) {
double m_AB = (yb-ya)/(xb-xa);
double m_AC = (yc-ya)/(xc-xa);
double m_BC = (yc-yb)/(xc-xb);
double E_AB = yb - m_AB * xb;
double E_AC = yc - m_AC * xc;
double E_BC = yc - m_BC * xc;
cout << "m, E" << endl;
cout << "AB " << m_AB << " " << E_AB << endl;
cout << "AC " << m_AC << " " << E_AC << endl;
cout << "BC " << m_BC << " " << E_BC << endl << endl;
EligneA_m = m_AB;
EligneA_E = E_AB;
MinX_linA = min (xa,xb);
MaxX_linA = max (xa,xb);
EligneB_m = m_AC;
EligneB_E = E_AC;
MinX_linB = min (xa,xc);
MaxX_linB = max (xa,xc);
EligneC_m = m_BC;
EligneC_E = E_BC;
MinX_linC = min (xb,xc);
MaxX_linC = max (xb,xc);
}
else {
double m_AD = (yd-ya)/(xd-xa);
double m_BD = (yd-yb)/(xd-xb);
double m_CD = (yd-yc)/(xd-xc);
double m_AB = (yb-ya)/(xb-xa);
double m_AC = (yc-ya)/(xc-xa);
double m_BC = (yc-yb)/(xc-xb);
double E_AD = yd - m_AD * xd;
double E_BD = yd - m_BD * xd;
double E_CD = yd - m_CD * xd;
double E_AB = yb - m_AB * xb;
double E_AC = yc - m_AC * xc;
double E_BC = yc - m_BC * xc;
cout << "AB" << m_AB << " " << E_AB << endl;
cout << "AC" << m_AC << " " << E_AC << endl;
cout << "AD" << m_AD << " " << E_AD << endl;
cout << "BC" << m_BC << " " << E_BC << endl;
cout << "BD" << m_BD << " " << E_BD << endl;
cout << "CD" << m_CD << " " << E_CD << endl << endl;
/// test of order, ab, ac, ad, bc, bd, cd (2 possibilities should be excluded!)
/// find angles BAD, CAB and CAD
// vectors AB, AC, AD
///AB
double Vab_x = xb-xa;
double Vab_y = yb-ya;
double Vab_L = sqrt(Vab_x*Vab_x+Vab_y*Vab_y);
double Nab_x = Vab_x / Vab_L;
double Nab_y = Vab_y / Vab_L;
///AC
double Vac_x = xc-xa;
double Vac_y = yc-ya;
double Vac_L = sqrt(Vac_x*Vac_x+Vac_y*Vac_y);
double Nac_x = Vac_x / Vac_L;
double Nac_y = Vac_y / Vac_L;
///AD
double Vad_x = xd-xa;
double Vad_y = yd-ya;
double Vad_L = sqrt(Vad_x*Vad_x+Vad_y*Vad_y);
double Nad_x = Vad_x / Vad_L;
double Nad_y = Vad_y / Vad_L;
/// dot product, angles
double D_BAD = acos (Nab_x * Nad_x + Nab_y * Nad_y) * 180.0 / PI;
double D_CAB = acos (Nab_x * Nac_x + Nab_y * Nac_y) * 180.0 / PI;
double D_CAD = acos (Nac_x * Nad_x + Nac_y * Nad_y) * 180.0 / PI;
cout << "BAC = " << D_CAB << "°" << endl;
cout << "BAD = " << D_BAD << "°" << endl;
cout << "CAD = " << D_CAD << "°" << endl;
if (D_CAB > D_BAD) {
if (D_CAB > D_CAD) {
/// ACDB
// ordered values
EligneA_m = m_AC;
EligneA_E = E_AC;
MinX_linA = min (xa,xc);
MaxX_linA = max (xa,xc);
EligneB_m = m_CD;
EligneB_E = E_CD;
MinX_linB = min (xc,xd);
MaxX_linB = max (xc,xd);
EligneC_m = m_BD;
EligneC_E = E_BD;
MinX_linC = min (xd,xb);
MaxX_linC = max (xd,xb);
EligneD_m = m_AB;
EligneD_E = E_AB;
MinX_linD = min (xa,xb);
MaxX_linD = max (xa,xb);
}
else {
/// ACBD
// ordered values
EligneA_m = m_AC;
EligneA_E = E_AC;
MinX_linA = min (xa,xc);
MaxX_linA = max (xa,xc);
EligneB_m = m_BC;
EligneB_E = E_BC;
MinX_linB = min (xc,xb);
MaxX_linB = max (xc,xb);
EligneC_m = m_BD;
EligneC_E = E_BD;
MinX_linC = min (xd,xb);
MaxX_linC = max (xd,xb);
EligneD_m = m_AD;
EligneD_E = E_AD;
MinX_linD = min (xa,xd);
MaxX_linD = max (xa,xd);
}
}
else if (D_BAD > D_CAD) {
/// ABCD // ordered values
EligneA_m = m_AB;
EligneA_E = E_AB;
MinX_linA = min (xa,xb);
MaxX_linA = max (xa,xb);
EligneB_m = m_BC;
EligneB_E = E_BC;
MinX_linB = min (xc,xb);
MaxX_linB = max (xc,xb);
EligneC_m = m_CD;
EligneC_E = E_CD;
MinX_linC = min (xc,xd);
MaxX_linC = max (xc,xd);
EligneD_m = m_AD;
EligneD_E = E_AD;
MinX_linD = min (xa,xd);
MaxX_linD = max (xa,xd);
}
else if (D_BAD < D_CAD) {
/// ACBD // ordered values
EligneA_m = m_AC;
EligneA_E = E_AC;
MinX_linA = min (xa,xc);
MaxX_linA = max (xa,xc);
EligneB_m = m_BC;
EligneB_E = E_BC;
MinX_linB = min (xc,xb);
MaxX_linB = max (xc,xb);
EligneC_m = m_BD;
EligneC_E = E_BD;
MinX_linC = min (xd,xb);
MaxX_linC = max (xd,xb);
EligneD_m = m_AD;
EligneD_E = E_AD;
MinX_linD = min (xa,xd);
MaxX_linD = max (xa,xd);
}
}
/// SOLUTION 1 (other solution n°2 just change X fixed to Y fixed)
double inchUN = 0;
double UNIT = 0;
double DPI = 600;
cout << endl << "UNIT (600 DPI)?" << endl;
cin >> inchUN;
UNIT = 2.54 * inchUN / 600;
cout << endl << "UNIT = " << UNIT << endl;
cout << endl << "| | *solution 1, all vertical" << endl;
// MEAT
/// left
X = MinX;
Z = ((yc*Ty+yc*Cy-Tc-Cc+(xc-X)*Tx+(xc-X)*Cx+1)*MeatDmax+yc*My-Mc+(xc-X)*Mx)/((Ty+Cy)*MeatDmax+My);
A_RealMeatMax = Z;
Z = ((yc*Ty+yc*Cy-Tc-Cc+(xc-X)*Tx+(xc-X)*Cx+1)*MeatDmin+yc*My-Mc+(xc-X)*Mx)/((Ty+Cy)*MeatDmin+My);
A_RealMeatMin = Z;
/// right
X = MaxX;
Z = ((yc*Ty+yc*Cy-Tc-Cc+(xc-X)*Tx+(xc-X)*Cx+1)*MeatDmax+yc*My-Mc+(xc-X)*Mx)/((Ty+Cy)*MeatDmax+My);
B_RealMeatMax = Z;
Z = ((yc*Ty+yc*Cy-Tc-Cc+(xc-X)*Tx+(xc-X)*Cx+1)*MeatDmin+yc*My-Mc+(xc-X)*Mx)/((Ty+Cy)*MeatDmin+My);
B_RealMeatMin = Z;
// test
cout << "MEAT" << endl;
cout << "A MAX (Z): " << A_RealMeatMax << endl;
cout << "A MIN (Z): " << A_RealMeatMin << endl;
cout << "B MAX (Z): " << B_RealMeatMax << endl;
cout << "B MIN (Z): " << B_RealMeatMin << endl;
// Cheese
/// left
X = MinX;
Z = ((yc*Ty-Tc+(xc-X)*Tx+1)*CheeseDmax+yc*Cy-Cc+(xc-X)*Cx)/(Ty*CheeseDmax+Cy);
A_RealCheeseMax = Z;
Z = ((yc*Ty-Tc+(xc-X)*Tx+1)*CheeseDmin+yc*Cy-Cc+(xc-X)*Cx)/(Ty*CheeseDmin+Cy);
A_RealCheeseMin = Z;
/// right
X = MaxX;
Z = ((yc*Ty-Tc+(xc-X)*Tx+1)*CheeseDmax+yc*Cy-Cc+(xc-X)*Cx)/(Ty*CheeseDmax+Cy);
B_RealCheeseMax = Z;
Z = ((yc*Ty-Tc+(xc-X)*Tx+1)*CheeseDmin+yc*Cy-Cc+(xc-X)*Cx)/(Ty*CheeseDmin+Cy);
B_RealCheeseMin = Z;
// test
cout << "CHEESE" << endl;
cout << "A MAX (Z): " << A_RealCheeseMax << endl;
cout << "A MIN (Z): " << A_RealCheeseMin << endl;
cout << "B MAX (Z): " << B_RealCheeseMax << endl;
cout << "B MIN (Z): " << B_RealCheeseMin << endl;
/// KEEP/MAKE THE DATA & FORMULAE
/// Meat
double a_m_AB = abs(MaxX - MinX);
double a_m_AstaX = MinX;
double a_m_AstaZ = A_RealMeatMax;
double a_m_AendX = MinX;
double a_m_AendZ = A_RealMeatMin;
double a_m_BstaX = MaxX;
double a_m_BstaZ = B_RealMeatMax;
double a_m_BendX = MaxX;
double a_m_BendZ = B_RealMeatMin;
double a_m_Ai = (Mc+Mx*(a_m_AstaX-xc)+My*(a_m_AstaZ-yc));
double a_m_Ao = (Mc+Mx*(a_m_AendX-xc)+My*(a_m_AendZ-yc));
double a_m_Atopi = (Tc+Tx*(a_m_AstaX-xc)+Ty*(a_m_AstaZ-yc))+(Cc+Cx*(a_m_AstaX-xc)+Cy*(a_m_AstaZ-yc));
double a_m_Atopo = (Tc+Tx*(a_m_AendX-xc)+Ty*(a_m_AendZ-yc))+(Cc+Cx*(a_m_AendX-xc)+Cy*(a_m_AendZ-yc));
double a_m_Bi = (Mc+Mx*(a_m_BstaX-xc)+My*(a_m_BstaZ-yc));
double a_m_Bo = (Mc+Mx*(a_m_BendX-xc)+My*(a_m_BendZ-yc));
double a_m_Btopi = (Tc+Tx*(a_m_BstaX-xc)+Ty*(a_m_BstaZ-yc))+(Cc+Cx*(a_m_BstaX-xc)+Cy*(a_m_BstaZ-yc));
double a_m_Btopo = (Tc+Tx*(a_m_BendX-xc)+Ty*(a_m_BendZ-yc))+(Cc+Cx*(a_m_BendX-xc)+Cy*(a_m_BendZ-yc));
/// Cheese
double a_c_AB = abs(MaxX - MinX);
double a_c_AstaX = MinX;
double a_c_AstaZ = A_RealCheeseMax;
double a_c_AendX = MinX;
double a_c_AendZ = A_RealCheeseMin;
double a_c_BstaX = MaxX;
double a_c_BstaZ = B_RealCheeseMax;
double a_c_BendX = MaxX;
double a_c_BendZ = B_RealCheeseMin;
double a_c_Ai = (Cc+Cx*(a_c_AstaX-xc)+Cy*(a_c_AstaZ-yc));
double a_c_Ao = (Cc+Cx*(a_c_AendX-xc)+Cy*(a_c_AendZ-yc));
double a_c_Atopi = (Tc+Tx*(a_c_AstaX-xc)+Ty*(a_c_AstaZ-yc));
double a_c_Atopo = (Tc+Tx*(a_c_AendX-xc)+Ty*(a_c_AendZ-yc));
double a_c_Bi = (Cc+Cx*(a_c_BstaX-xc)+Cy*(a_c_BstaZ-yc));
double a_c_Bo = (Cc+Cx*(a_c_BendX-xc)+Cy*(a_c_BendZ-yc));
double a_c_Btopi = (Tc+Tx*(a_c_BstaX-xc)+Ty*(a_c_BstaZ-yc));
double a_c_Btopo = (Tc+Tx*(a_c_BendX-xc)+Ty*(a_c_BendZ-yc));
//_____________________________________________________________________________________
cout << endl << "meat:" << endl;
cout << a_m_AB << endl;
cout << a_m_AstaX << endl;
cout << a_m_AstaZ << endl;
cout << a_m_AendX << endl;
cout << a_m_AendZ << endl;
cout << a_m_BstaX << endl;
cout << a_m_BstaZ << endl;
cout << a_m_BendX << endl;
cout << a_m_BendZ << endl;
cout << a_m_Ai << endl;
cout << a_m_Ao << endl;
cout << a_m_Atopi << endl;
cout << a_m_Atopo << endl;
cout << a_m_Bi << endl;
cout << a_m_Bo << endl;
cout << a_m_Btopi << endl;
cout << a_m_Btopo << endl;
cout << "verifications, values sould be very near equality" << endl;
cout << "A start REAL = " << a_m_Ai/(1-a_m_Atopi) << endl;
cout << "B start REAL = " << a_m_Bi/(1-a_m_Btopi) << endl;
cout << "diff = " << abs(a_m_Ai/(1-a_m_Atopi) - a_m_Bi/(1-a_m_Btopi)) << endl;
cout << "A end REAL = " << a_m_Ao/(1-a_m_Atopo) << endl;
cout << "B end REAL = " << a_m_Bo/(1-a_m_Btopo) << endl;
cout << "diff = " << abs(a_m_Ao/(1-a_m_Atopo) - a_m_Bo/(1-a_m_Btopo)) << endl;
cout << endl << "cheese:" << endl;
cout << a_c_AB << endl;
cout << a_c_AstaX << endl;
cout << a_c_AstaZ << endl;
cout << a_c_AendX << endl;
cout << a_c_AendZ << endl;
cout << a_c_BstaX << endl;
cout << a_c_BstaZ << endl;
cout << a_c_BendX << endl;
cout << a_c_BendZ << endl;
cout << a_c_Ai << endl;
cout << a_c_Ao << endl;
cout << a_c_Atopi << endl;
cout << a_c_Atopo << endl;
cout << a_c_Bi << endl;
cout << a_c_Bo << endl;
cout << a_c_Btopi << endl;
cout << a_c_Btopo << endl;
cout << "verifications, values sould be very near equality" << endl;
cout << "A start REAL = " << a_c_Ai/(1-a_c_Atopi) << endl;
cout << "B start REAL = " << a_c_Bi/(1-a_c_Btopi) << endl;
cout << "diff = " << abs(a_c_Ai/(1-a_c_Atopi) - a_c_Bi/(1-a_c_Btopi)) << endl;
cout << "A end REAL = " << a_c_Ao/(1-a_c_Atopo) << endl;
cout << "B end REAL = " << a_c_Bo/(1-a_c_Btopo) << endl;
cout << "diff = " << abs(a_c_Ao/(1-a_c_Atopo) - a_c_Bo/(1-a_c_Btopo)) << endl;
/// _____________________________________________________________________________
/// containers
vector <double> sideA; // intersections pour SVG
vector <double> sideB;
vector <double> sideC;
vector <double> sideD;
vector <double> fileA; // fichiers TXT
vector <double> fileB;
vector <double> fileC;
vector <double> fileD;
// processing variables
/// !!! DONT FORGET TO RESET THEM !!!
double lengthA = 0;
double lengthB = 0;
double amplifi = 0;
double SIZE_A = 0;
double SIZE_B = 0;
double D_START = 0;
double D_TOP_S = 0;
double D_END = 0;
double D_TOP_E = 0;
double A_X = 0;
double B_X = 0;
int iteration = 0;
double VAR_Z = 0;
double SUM = 0;
double percent = 0;
double POS_A = 0;
double POS_B = 0;
double POS_B2 = 0;
double unitBis = 0;
double unitTer = 0;
double PilotD = 0;
double TOP_D = 0;
double D_REAL = 0;
double slope_a = 0;
double add_a = 0;
double slope_b = 0;
double add_b = 0;
double AB_x = 0;
double AB_y = 0;
bool testAB = false;
double AD_x = 0;
double AD_y = 0;
bool testAD = false;
double BC_x = 0;
double BC_y = 0;
bool testBC = false;
double CD_x = 0;
double CD_y = 0;
bool testCD = false;
/// MEAT
lengthA = abs(a_m_AendZ-a_m_AstaZ); // a_c for cheese solution 1, b_c = cheese sol 2, etc.
lengthB = abs(a_m_BendZ-a_m_BstaZ);
// test
if (lengthA>lengthB) {
amplifi = lengthA/lengthB;
cout << "Pilot is B" << endl;
cout << "amp = " << amplifi << endl;
SIZE_A = lengthB;
SIZE_B = lengthA;
POS_A = a_m_BstaZ;
POS_B = a_m_AstaZ;
A_X = a_m_BstaX;
B_X = a_m_AstaX;
D_START = a_m_Bi;
D_TOP_S = a_m_Btopi;
D_END = a_m_Bo;
D_TOP_E = a_m_Btopo;
}
else {
amplifi = lengthB/lengthA;
cout << "Pilot is A" << endl;
cout << "amp = " << amplifi << endl;
SIZE_A = lengthA;
SIZE_B = lengthB;
POS_A = a_m_AstaZ;
POS_B = a_m_BstaZ;
A_X = a_m_AstaX;
B_X = a_m_BstaX;
D_START = a_m_Ai;
D_TOP_S = a_m_Atopi;
D_END = a_m_Ao;
D_TOP_E = a_m_Atopo;
}
/// processing
/// ATTENTION, BEFORE THE FIRST VALUE (JUST A POINT, A MARK)
/// SHOULD BE PUSHED IN THE VECTORS !!!!
/// CAREFUL WITH SVGs, 90 DPI!
vector <double> log;
while (percent < 1) {
/// intersections sides,
/// slopes ba0 and ba1 // slope is m, add is E
slope_a = (POS_B - POS_A )/(B_X-A_X);
add_a = POS_B - slope_a * B_X;
slope_b = (POS_A - POS_B2)/(A_X-B_X);
add_b = POS_A - slope_b * A_X;
cout << "Ax " << A_X << " Bx " << B_X << " mba0 " << slope_a << " eba0 " << add_a <<" mab1 " << slope_b << " eab1 " << add_b << endl;
/// intersection & test in segment via X
// AB
AB_x = -(add_a - EligneA_E) / (slope_a - EligneA_m);
AB_y = EligneA_m * AB_x + EligneA_E;
cout << endl << "ABx " << AB_x << " ABy " << AB_y << endl;
if ((AB_x-MaxX_linA)/(MinX_linA-MaxX_linA)>=0){
if ((AB_x-MaxX_linA)/(MinX_linA-MaxX_linA)<=1) {
testAB = true;
cout << "intersection on Line 1: " << endl << "x = " << AB_x << " | y = " << AB_y << endl << endl;
log.push_back(AB_x);
log.push_back(AB_y);
}}
AB_x = -(add_b - EligneA_E) / (slope_b - EligneA_m);
AB_y = EligneA_m * AB_x + EligneA_E;
cout << endl << "ABx2 " << AB_x << " ABy2 " << AB_y << endl;
if ((AB_x-MaxX_linA)/(MinX_linA-MaxX_linA)>=0){
if ((AB_x-MaxX_linA)/(MinX_linA-MaxX_linA)<=1) {
testAB = true;
cout << "2nd intersection on Line 1: " << endl << "x = " << AB_x << " | y = " << AB_y << endl << endl;
log.push_back(AB_x);
log.push_back(AB_y);
}}
// BC
BC_x = -(add_a - EligneB_E) / (slope_a - EligneB_m);
BC_y = EligneB_m * BC_x + EligneB_E;
cout << endl << "BCx " << BC_x << " BCy " << BC_y << endl;
if ((BC_x-MaxX_linB)/(MinX_linB-MaxX_linB)>=0) {
if ((BC_x-MaxX_linB)/(MinX_linB-MaxX_linB)<=1) {
testBC = true;
cout << "intersection on Line 2: " << endl << "x = " << BC_x << " | y = " << BC_y << endl << endl;
log.push_back(BC_x);
log.push_back(BC_y);
}}
BC_x = -(add_b - EligneB_E) / (slope_b - EligneB_m);
BC_y = EligneB_m * BC_x + EligneB_E;
cout << endl << "BCx2 " << BC_x << " BCy2 " << BC_y << endl;
if ((BC_x-MaxX_linB)/(MinX_linB-MaxX_linB)>=0) {
if ((BC_x-MaxX_linB)/(MinX_linB-MaxX_linB)<=1) {
testBC = true;
cout << "2nd intersection on Line 2: " << endl << "x = " << BC_x << " | y = " << BC_y << endl << endl;
log.push_back(BC_x);
log.push_back(BC_y);
}}
// CD
CD_x = -(add_a - EligneC_E) / (slope_a - EligneC_m);
CD_y = EligneC_m * CD_x + EligneC_E;
cout << endl << "CDx " << CD_x << " CDy " << CD_y << endl;
if ((CD_x-MaxX_linC)/(MinX_linC-MaxX_linC)>=0) {
if ((CD_x-MaxX_linC)/(MinX_linC-MaxX_linC)<=1) {
testCD = true;
cout << "intersection on Line 3: " << endl << "x = " << CD_x << " | y = " << CD_y << endl << endl;
log.push_back(CD_x);
log.push_back(CD_y);
}}
CD_x = -(add_b - EligneC_E) / (slope_b - EligneC_m);
CD_y = EligneC_m * CD_x + EligneC_E;
cout << endl << "CDx2 " << CD_x << " CDy2 " << CD_y << endl;
if ((CD_x-MaxX_linC)/(MinX_linC-MaxX_linC)>=0) {
if ((CD_x-MaxX_linC)/(MinX_linC-MaxX_linC)<=1) {
testCD = true;
cout << "2nd intersection on Line 3: " << endl << "x = " << CD_x << " | y = " << CD_y << endl << endl;
log.push_back(CD_x);
log.push_back(CD_y);
}}
// BC
AD_x = -(add_a - EligneD_E) / (slope_a - EligneD_m);
AD_y = EligneD_m * AD_x + EligneD_E;
cout << endl << "ADx " << AD_x << " ADy " << AD_y << endl;
if ((AD_x-MaxX_linD)/(MinX_linD-MaxX_linD)>=0) {
if ((AD_x-MaxX_linD)/(MinX_linD-MaxX_linD)<=1) {
testAD = true;
cout << "intersection on Line 4: " << endl << "x = " << AD_x << " | y = " << AD_y << endl << endl;
log.push_back(AD_x);
log.push_back(AD_y);
}}
AD_x = -(add_b - EligneD_E) / (slope_b - EligneD_m);
AD_y = EligneD_m * AD_x + EligneD_E;
cout << endl << "ADx2 " << AD_x << " ADy2 " << AD_y << endl;
if ((AD_x-MaxX_linD)/(MinX_linD-MaxX_linD)>=0) {
if ((AD_x-MaxX_linD)/(MinX_linD-MaxX_linD)<=1) {
testAD = true;
cout << "2nd intersection on Line 4: " << endl << "x = " << AD_x << " | y = " << AD_y << endl << endl;
log.push_back(AD_x);
log.push_back(AD_y);
}}
unitBis = sqrt((-tan(atan((POS_A-POS_B)/a_m_AB))*UNIT)*(-tan(atan((POS_A-POS_B)/a_m_AB))*UNIT)+UNIT*UNIT);
unitTer = unitBis * amplifi - unitBis;
percent = SUM / SIZE_A;
PilotD = D_START - (D_START - D_END) * percent;
TOP_D = D_TOP_S - (D_TOP_S - D_TOP_E) * percent;
D_REAL = PilotD / (1-TOP_D);
VAR_Z = unitBis * 1 / D_REAL;
SUM = SUM + VAR_Z;
POS_A = POS_A + VAR_Z;
POS_B = POS_B + VAR_Z * amplifi;
POS_B2 = POS_B + unitTer;
iteration = iteration + 1;
cout << endl << iteration << endl;
cout << "unitBis "<< unitBis << endl;
cout << "unitTer "<< unitTer << endl;
cout << "POS_B2 "<< POS_B2 << endl;
cout << "percent "<< percent << endl;
cout << "PilotD "<< PilotD << endl;
cout << "TOP_D "<< TOP_D << endl;
cout << "D_REAL "<< D_REAL << endl;
cout << "VAR_Z "<< VAR_Z << endl;
cout << "SUM "<< SUM << endl;
cout << "POS_A "<< POS_A << endl;
cout << "POS_B "<< POS_B << endl << endl;
/// OKAY JUSQUE ICI
}
/// _____________________WRITE_LOG FILE___________________________
ofstream output_file("./log.csv");
while (!log.empty()) {
// write file
output_file << "\n" << log.front() << ";" ;
log.erase(log.begin());
output_file << log.front() << ";" ;
log.erase(log.begin());
}
output_file.close();
/// RESET VARIABLES (pas oublier amplifi)
return(0);
}
CLICK ON THE PICTURE TO ZOOM
To have a good (near invisible) junction between two triangular zones means succeeding, with different lines boldness and angles, to cover the paper with the same proportions of colors. If it is visually good, it means that the drawing instrument is well calibrated, and that all the calculus were correct.
In my next drawing D65 n°6 I will have a lot of junctions like this one, the challenge will be to make them all as good as this one! :)
HI-RES. PICTURE – CLICK TO ZOOM!
A study for new graphic solutions.
Hi-resolution picture: CLICK ON IT TO ZOOM!
The two largest rectangles have the same color average: same colors in the same proportions.
The one on the top is made of 4 layers, one color per layer, one spatial frequency per color, and the angles between the layers are “optimized” in order to get rid of moiré effects.
On the other one there’s also 4 layers, but with a unique frequency, a 45° rotation and the colors are randomly diffused.
Both are trying to “match” the average color of the background and in both paint is covering 60% of the paper.
The 1st one is almost invisible, the second appears to contain intense colors.
CLICK ON THE PICTURE TO ZOOM!
I’m gonna do a “lamp simulation” (a circular gradient with constant tint and varying brightness, based on the abstract model of a “perfect lamp,”) based on 11 colors: 3 times RGB with 3 levels of brightness (I dont enter into the detail of how I choosed them) and Black/White.
