#############################################
# Gillette Sensor - The Best a Man Can Get  #
# Vadim Makhervaks & Vitaly Surazhsky       #
# Copyright(C) 1996                         #
#                                           #
# Technion, Computer Science Department     #
# Winter 1995, CAGD Course                  #
#############################################

cHandle = "192,192,192";
cPlast = "0,63,255";
cBlade = "221,221,221";
cBand = "255,255,255";


rNeck = 0.1;
oval_ratio = 3;
lnNeck = 0.5;

rHandle = 1.5*rNeck;
lnHandle0 = 3*0.8;
lnHandle1 = 0.2;
lnHandle2 = 1*0.8; 

lnHead = 1.5*lnHandle2/6;
OO = point(0, 0, 0);
#//////////////////////////////////////////
# Neck creation /////////////////////////
#//////////////////////////////////////////

plate = circle(vector(0,0,0), rNeck);
#interact(plate);

oval = plate*sx(oval_ratio);
oval = trans( vector(0, 0, lnNeck))*oval;
oval = sy(cos(pi/4))*oval;

#color(oval, green);

plate = rx(45)*plate;
#interact(plate);

neck = sfromcrvs(list(plate, oval), 2);

oval = boolone(oval);
plate = boolone(plate);

neck = neck + oval;
neck = neck + plate;
#interact(  neck );

#//////////////////////////////////////////
#neck = neck*sx(-1);
#//////////////////////////////////////////

free(plate);
free(oval);

#//////////////////////////////////////////
# Ear creation ////////////////////////////
#//////////////////////////////////////////
dx = 2*rNeck*oval_ratio;
dy = rNeck*cos(pi/4);
dz = lnNeck/2;
eps = dx/8;
ear = box( vector(0, 0, 0), dx, dy, dz);

ear = ear*tz(dz/2)*tx(-dx/2)*ty(-dy/2);

ear = ear*sx(-1);

cutter = box( vector(0, 0, 0), dx/2, 2*dy, 2*dz);
#color(cutter, red);

cutter = cutter*tx(-dx/4)*ty(-dy)*tz(-dz);

alfa = 180*atan((dx - 2*rNeck)/(2*lnNeck))/pi;
cutter1 = cutter*ry(-alfa);

cutter1 = cutter1*tx(-dx/2-eps)*tz(dz);
ear = ear - cutter1;

cutter2 = cutter*ry(alfa);
cutter2 = cutter2*tx(dx/2+eps)*tz(dz);

ear = ear - cutter2;

#color(ear, green);
#interact(list(neck, ear));

free(alfa);
free(cutter);
free(cutter1);
free(cutter2);
free(dx);
free(dy);
free(dz);
free(eps);

#//////////////////////////////////////////
# Handle creation /////////////////////////
#//////////////////////////////////////////

resolution = 20;
back = sphere( vector(0, 0, 0), rHandle);

resolution =  10;

plate1 = circle( vector(0, 0, 0), rHandle);
plate2 = plate1*trans( vector(0, 0, lnHandle0));
plate3 = circle( vector(0, 0, 0), rNeck);
plate3 = plate3*trans( vector(0, 0, lnHandle0 + lnHandle1));
plate4 = plate3*trans( vector(0, 0, lnHandle2));

sclPts = list(
ctlpt(e3, 0, rHandle, 0),
ctlpt(e3, lnHandle0, rHandle, 0),
ctlpt(e3, lnHandle0+lnHandle1, rNeck, 0),
ctlpt(e3, lnHandle0+lnHandle1+lnHandle2, rNeck, 0)
);
sclCrv = cbspline(2, sclPts, list(KV_OPEN));

axePts = list(
ctlpt(e3, 0, 0, 0),
ctlpt(e3, 0, 0, lnHandle0),
ctlpt(e3, 0, 0, lnHandle0+lnHandle1),
ctlpt(e3, 0, 0, lnHandle0+lnHandle1+lnHandle2)
);
axeCrv = cbspline(2, axePts, list(KV_OPEN));

sectCrv = circle(vector(0,0,0), 1);

handle = swpsclsrf(sectCrv, axeCrv, sclCrv, off, 1);

lst = list( plate1, plate2, plate3, plate4);
#color(lst, red);
#view(lst, on);
#handle = sfromcrvs( lst, 2);

#view(handle, on);


#back = back*sx(-1);
handle = handle + back;
#view(handle, on);

free(plate1);
free(plate2);
free(plate3);
free(plate4);
free(lst);
free(back);

#///////////////////////////////////////////////
# Handle + Neck ////////////////////////////////
#///////////////////////////////////////////////

handle = handle*trans( vector(0, 0, -lnHandle2 - lnHandle1 - lnHandle0));

palka = handle;

neck = neck*rx(-45);
ear = ear*rx(-45);
handle = handle + neck;
#view(handle, on);

#///////////////////////////////////////////////
# Head creation ////////////////////////////////
#///////////////////////////////////////////////

origin = vector(0.25*lnHead, -0.1*lnHead, 0.3*lnHead);

head = box( vector(0, 0, 0), 1, 0.3, 6);
head = head*scale( vector(lnHead,lnHead , lnHead));


y = -0.0;
r = 0.55;
resolution = 20;
cylin1 = cylin( vector(0.5, y, -0.1), vector(0, 0, 7), r);
cylin1 = cylin1*scale(  vector(lnHead, lnHead, lnHead));
#color(cylin1, green);
#interact(list(cylin1,head) );

head = head * cylin1;
#interact(head);


band = box( vector(0, 0, 0), 0.2, 0.05, 6);
band = band*ty(0.28)*tx(0.8)*tz(0.15)*scale( vector(lnHead,lnHead , lnHead*0.95));
#color(band, red);

asd = box( vector(0, 0, 0), 0.25, 0.15, 6);
asd = asd*ty(0.18)*tx(-0.1)*tz(0.15)*scale( vector(lnHead, lnHead, lnHead*0.95));

head = head - asd;
#interact(list(head, band));

free(asd);
free(y);
free(r);
free(cylin1);


#///////////////////////////////////////////////
# Cover creation ///////////////////////////////
#///////////////////////////////////////////////

middle = vector( 0.5*lnHead, 0, 3*lnHead);
cover1 = head*trans( -middle);

cover1 = cover1*scale( vector(1.2, 1.2, 1.2));
cover2 = cover1*scale( vector(1.05, 1, 1.05));

cover1 = cover1*trans( vector(0, -0.05*lnHead, 0));


cover1 = cover1*trans( middle);
cover2 = cover2*trans( middle);

#color(cover1, red);
#interact(list(cover1, cover2));

cover = cover2 - cover1;
#interact(cover);

free(cover1);
free(cover2);

#////////////////////////////////////////////
# Makes some holy whole hole ////////////////
#////////////////////////////////////////////

hole = head*scale( vector(1 - 0.5, 2, 1-0.1));
hole = hole*trans(origin );
#color(hole, red);

#interact(list(hole, head));

head = head - hole;
#interact(head);

free(origin);
free(hole);

#/////////////////////////////////////////////
# blade creation /////////////////////////////
#/////////////////////////////////////////////

dx = 0.2*lnHead;
dy = 0.2*lnHead;
dz = 5.40*lnHead;
middle = vector(dx/2, dy/2, dz/2);

blade = box( vector(0, 0, 0), dx, dy, dz);
blade = blade*trans(-middle);
bigone = blade*scale( vector(2, 2, 2));
blade = blade*rz(45);
blade = blade*trans( vector(0, -dy, 0));

#interact(list(blade, bigone));

blade = blade * bigone;
blade = blade*trans( vector(0, dy, 0) );
#color(blade, red);

#interact(list(blade, OO));

free(dx);
free(dy);

free(middle);
#///////////////////////////////////////////////
# Blade Connection /////////////////////////////
#///////////////////////////////////////////////

blade1 = blade*rz(-60)*tx(0.55*lnHead)*ty(0.2*lnHead)*tz(dz/2+0.3*lnHead);
blade2 = blade1*tx(-0.18*lnHead);
blade = blade1 + blade2;

#interact(list(blade, head, band));


free(blade1);
free(blade2);
free(dz);
#////////////////////////////////////////////////
# Head Connectors Creation //////////////////////
#////////////////////////////////////////////////

lst = list( ctlpt(E3, 0, 0, 0),
            ctlpt(E3, 1, 0, 0),
            ctlpt(E3, 1, 1, 0),
            ctlpt(E3, 0, 1, 0),
            ctlpt(E3, 0, 0, 0));

base = cbspline(2, lst, list(KV_OPEN));

dz = 0.7;

middle = vector(0.5, 0.5, 0.5);
base1 = base*trans(-middle);
base2 = base1*sy(2)*tz(dz)*trans(middle);
base1 = base1*trans(middle);

wall1 = boolone(base1);
wall2 = boolone(base2);

connector = sfromcrvs(list(base1, base2),2);
connector = connector + wall1;
connector = connector + wall2;

n = lnHead/2;
connector = connector*scale( vector(n, n, n));
#view(connector,on);


free(middle);
free(base);
free(base1);
free(base2);
free(lst);
free(wall1);
free(wall2);

#/////////////////////////////////////////////////
# Connect to Handle   ////////////////////////////
#/////////////////////////////////////////////////

connector = connector*tz(lnNeck)*ty(-n/2)*rx(-45)*tx(-n/2);

connector1 = connector*tx(3*n/2);
connector2 = connector*tx(-3*n/2);

connector = connector1 + connector2;


xhead = head*tz(-6*lnHead/2)*tx(-lnHead/2);
xblade = blade*tz(-6*lnHead/2)*tx(-lnHead/2);
band = band*tz(-6*lnHead/2)*tx(-lnHead/2);


xhead = xhead*rx(90)*rz(-90)*tz(lnNeck+dz*n)*rx(-45);
xblade = xblade*rx(90)*rz(-90)*tz(lnNeck+dz*n)*rx(-45);
band = band*rx(90)*rz(-90)*tz(lnNeck+dz*n)*rx(-45);


attrib(xhead, "rgb", cPlast);
attrib(xblade, "rgb", cBlade);
attrib(connector, "rgb", cPlast);
attrib(band, "rgb", cBand);

head = list(xhead, xblade, connector, band);

#interact(list(handle, head));

free(band);
free(blade);
free(xhead);
free(xblade);
free(connector);
free(connector1);
free(connector2);
free(n);
free(dz);


#########################################
# fixels and label

wFixel = 0.02;
v0 = vector(0, 0, 0);

sectFixel = circle(v0, wFixel);
baseFixel = circle(v0, rHandle);
fixel = sweepsrf(sectFixel, baseFixel, off);

tmpResolution = resolution;
resolution = 8;
fixel = gpolygon(fixel, on);
resolution = tmpResolution;
free(tmpResolution);

#interact(fixel);

ovalFixel = sphere(v0, rHandle);
ovalFixel = sx(1.3)*sy(0.95)*ovalFixel;

ovalLabel = box(v0, rHandle*2, rHandle*2, rHandle*8);
ovalLabel = tx(-rHandle)* ty(-rHandle)*tz(-rHandle*4)*ovalLabel;
ovalLabel = sx(1.2)*sy(0.6)*ovalLabel;
##interact(list(fixel, ovalFixel));

#ovalFixel = ovalLabel;
#ovalLabel = sx(1.2)*sy(0.7)*ovalLabel;

fixel = fixel*ovalFixel;
attrib(fixel, "rgb", cPlast);

label = cylin(v0, vector(0,0,-rHandle*3), rHandle + wFixel/2);
#label = tz(-rHandle*3/2)*label;
#interact(list(label));


label = label * ovalLabel;

delta = -rHandle*0.62;

fixelLst = nil();
offs = -lnHandle2 - lnHandle1;
for (1, 1, 16,
  offs = offs + delta:
  snoc(fixel*tz(offs), fixelLst)
);

offs = offs - rHandle*0.8;
label = label*tz(offs);
offs = offs - rHandle*3;
attrib(label, "rgb", cPlast);

for (1, 1, 3,
  offs = offs + delta:
  snoc(fixel*tz(offs), fixelLst)
);

#color(label, green);


attrib(handle, "rgb", cHandle);
attrib(handle, "reflect", on);
attrib(ear, "rgb", cPlast);

gillette = list(fixelLst, label, handle,  head, ear);
#interact(list(gillette, axes));

##################################
conusPts = list(
ctlpt(e3, 0, 0 ,0.3),
ctlpt(e3, 0, 0.2, 0.25),
ctlpt(e3, 0.198849, 0.446622, 0.2),
ctlpt(e3, 0.388092, 0.27319, 0.1),
ctlpt(e3, 0.456683, -0.0205096, 0.0857143),
ctlpt(e3, 0.296901, -0.319983, 0.126984),
ctlpt(e3, -0.0615095, -0.408089, 0.174603),
ctlpt(e3, -0.354675, -0.151595, 0.228571),
ctlpt(e3, -0.264229, 0.237913, 0.288889),
ctlpt(e3, 0.13106, 0.294365, 0.355556),
ctlpt(e3, 0.278551, -0.0635774, 0.428571),
ctlpt(e3, -0.0366691, -0.243284, 0.507937),
ctlpt(e3, -0.199344, 0.0392647, 0.593651),
ctlpt(e3, 0.055216, 0.147123, 0.685714),
ctlpt(e3, 0.0863636, -0.0647427, 0.784127),
ctlpt(e3, -0.0481125, -0.0277778, 0.888889),
ctlpt(e3, -0.0481125, -0.0277778, 1.1)
);

conusCurve = cbspline(4, conusPts, list(KV_OPEN));
#view(conusCurve, on);

scalePts = list( ctlpt(E3, 0.0, 0.45, 0),
          ctlpt(E3, 0.5, 0.4, 0),
          ctlpt(E3, 0.7, 0.35, 0),
          ctlpt(E3, 0.9, 0.3, 0),
	  ctlpt(E3, 1.0, 0, 0));
	
scaleCurve = cbspline(3, scalePts, list(KV_OPEN));

cut = circle(vector(0,0,0), 1);

srf  = swpsclsrf(cut, conusCurve, scaleCurve, off, 1);
srf = srf * rz(-90);
#view(srf, on);

boxBasePts = list( ctlpt(E3, -1, -1, -2),
            ctlpt(E3, 1, -1, -2),
            ctlpt(E3, 1, 1, -2),
            ctlpt(E3, -1, 1, -2),
            ctlpt(E3, -1, -1, -2));


boxBase = cbspline(2, boxBasePts, list(KV_OPEN));
boxPlate = boolone(boxBase);

#view(list(srf,boxBase), on);

circleBase = circle(vector(0,0,0), 1);
circlePlate = boolone(circleBase);

baseSrf = sfromcrvs(list(circleBase,boxBase), 2);
baseSrf = baseSrf + circlePlate + boxPlate;
color(baseSrf, blue);
attrib(srf, "rgb", "192, 192, 255");


srf = srf*tz(2)*tx(0.5)*ty(-0.5);
baseSrf = baseSrf*tz(2)*tx(0.5)*ty(-0.5);

#view(list(srf, baseSrf), on);
planeSrf = box(vector(0,0,0),5,5, 0.2);
planeSrf = tx(-2.5)*ty(-2.5)*tz(-0.2)*planeSrf;
attrib(planeSrf, "rgb", "127,63,31");
attrib(planeSrf, "texture", "wood");
attrib(baseSrf, "rgb", "0,255,127");


#xpalka = list(palka, head);
xpalka = gillette;

xpalka = xpalka * tz(lnHandle2+lnHandle1+lnHandle0+rHandle);
xpalka = xpalka*ry(90)*rx(45)*rz(-10);
xpalka = xpalka*tx(-1.8)*ty(1.3)*tz(rHandle*sin(PI*75/180));

#view(list(baseSrf,planeSrf,xpalka,srf), on);

#save("Gillette.dat", gillette);

#asd = load("Gillette.dat");
#view(asd, on);

#Lst = list(baseSrf,planeSrf,xpalka,srf);
#save("GilletteScene.dat", Lst);

view(gillette, on);
##################################


free(cover);
free(handle);
free(neck);