How to create a simple vortex on POV Ray, using the instruction union and difference.
// POV-Ray 3.7 Scene File "Prova4.pov"
// author: Max
// Date: 01/03/2015
//--------------------------------------------------------------------------
#if (version < 3.7) global_settings{ assumed_gamma 1.0 } #end
//--------------------------------------------------------------------------
#include "colors.inc"
#include "textures.inc"
//--------------------------------------------------------------------------
// camera ------------------------------------------------------------------
#declare Camera_0 = camera {ultra_wide_angle angle 65 // vista frontale
location <0.0 , 3.0 ,-3.5>
right x*image_width/image_height
look_at <0.0 ,-0.5 , 0.0>}
camera{Camera_0}
// sole ---------------------------------------------------------------------
light_source{<1500,3000,-3000> color White}
// cielo ---------------------------------------------------------------------
plane{<0,1,0>,1 hollow no_shadow
texture{ pigment{ Bright_Blue_Sky scale 1
}
finish {ambient 1 diffuse 0} }
scale 10000}
// nebbia ---------------------------------------------------------------------
fog{fog_type 2
distance 20
color rgb<1,0.98,0.9>
fog_offset 0.1
fog_alt 1
turbulence 0.8}
// terreno ------------------------------------------------------------------
// dimensioni del foro:
#declare ForointernoR = 1.00;
#declare Foroscala = 1.25;
#declare ForoR = 0.75;
//-------------------------
// piano forato:
union{
difference{
plane{<0,1,0>, 0 }
cylinder{<0,-ForoR,0>, <0,0.001,0>,ForointernoR+ForoR scale Foroscala}
cylinder{<0, -100,0>, <0,0.001,0>,ForointernoR scale Foroscala}
} // fine della differenza
torus{ ForointernoR+ForoR, ForoR
translate<0,-ForoR,0>scale Foroscala}
texture{Polished_Chrome
normal {spiral1 20 0.25 sine_wave
turbulence 0.1 rotate<90,0,0> scale <0.25,0.5,0.25> }
finish {ambient 0.15 diffuse 0.85 reflection 0.35}}
} // fine dell'unione
//sfera sospesa
sphere { <0,-ForoR,0>, ForoR/3
texture { pigment{ color rgb<0.75, 0.75, 0.75>}
finish { phong 1.0 reflection 0.01}
}
scale<1,1,1> rotate<0,0,0> translate<0,0.5,0>
} // fine della sfera -----------------------------------
//-----------------------------------------------------------------------fine
Here the picture obtained from the program written above.
In questo blog si parla di programmazione con il linguaggio C++, i post cercheranno di essere molto esplicativi sull'argomento trattato.
domenica 1 marzo 2015
A simple water scene
Here are some instruction how to create a flat water surface with a blue sky. The water effect is only simulated, no real waves are created by this code.
// POV-Ray 3.6 Scene File "Prova2.pov"
// created Max
// date: 01/03/2015
#include "colors.inc"
#include "textures.inc"
#include "textures.inc"
global_settings { assumed_gamma 1.1 }
// telecamera -----------------------------------------------------------
#declare Cam0 = camera {/*ultra_wide_angle*/ angle 65
location <0.0 , 1.0 ,-3.0>
look_at <0.0 , 0.8 , 0.0>}
camera{Cam0}
// sole ---------------------------------------------------------------
light_source{<1500,3000,-2500> color White}
// nebbia ---------------------------------------------------------------
fog{fog_type 2 distance 85 color rgb<1,0.99,0.9>
fog_offset 0.1 fog_alt 2.0 turbulence 0.2}
// cielo ---------------------------------------------------------------------
plane{<0,1,0>,1 hollow
texture{ pigment{ bozo turbulence 0.99
color_map { [0.5 rgb <0.30, 0.30, 1.0>*1]
[0.6 rgb <1,1,0.9>]
[1.0 rgb <0.2,0.2,0.2>]}
scale 3.5 translate<10,0,9>
}
finish {ambient 1 diffuse 0} }
scale 10000}
//--------------------------------------------------------------------------
//--------------------------------------------------------------------
plane{<0,1,0>, 0
texture{pigment{ rgb <0.2, 0.2, 0.2> }
normal { bumps 0.18 scale <1,0.25,0.35>*1 turbulence 0.8 }
finish { ambient 0.05 diffuse 0.55
brilliance 6.0 phong 0.8 phong_size 120
reflection 0.6 }
}
}
//--------------------------------------------------------------------
#declare Asta_H = 1.75;
#declare Asta_R = 0.20;
#declare Asta = // Oggetto
union{
cylinder {<0,-Asta_H,0>,<0,Asta_H,0>,Asta_R translate<0,0,0>
texture{pigment{spiral1 2
color_map{[0.0 White]
[0.5 White]
[0.5 rgb<1,0.5,0>]
[1.0 rgb<1,0.5,0>]}
rotate<90,0,0>
scale<1,0.3,1>}
normal {bumps 0.3 scale 0.025}
finish {ambient 0.05 diffuse 0.95
phong 1 reflection 0.05}
}
}
union{
cylinder{<0,-0.05,0>,<0,0.05,0>,Asta_R+0.05 translate<0,Asta_H.0>}
sphere {<0,0,0>,Asta_R+0.05 translate<0,Asta_H+0.1,0> }
torus {1.0,0.1 scale 0.12 translate<0,Asta_H+0.01,0>}
texture{pigment{color White}
normal {bumps 0.3 scale 0.025}
finish {ambient 0.15 diffuse 0.85 phong 1 reflection 0.05}}}
}// fine di Asta --------
//---------------------------------------------------------------------
object{Asta scale 1 rotate<0,0,2> translate <-1.0,0,3>}
//----------------------------------------------------------------- fine
// POV-Ray 3.6 Scene File "Prova2.pov"
// created Max
// date: 01/03/2015
#include "colors.inc"
#include "textures.inc"
#include "textures.inc"
global_settings { assumed_gamma 1.1 }
// telecamera -----------------------------------------------------------
#declare Cam0 = camera {/*ultra_wide_angle*/ angle 65
location <0.0 , 1.0 ,-3.0>
look_at <0.0 , 0.8 , 0.0>}
camera{Cam0}
// sole ---------------------------------------------------------------
light_source{<1500,3000,-2500> color White}
// nebbia ---------------------------------------------------------------
fog{fog_type 2 distance 85 color rgb<1,0.99,0.9>
fog_offset 0.1 fog_alt 2.0 turbulence 0.2}
// cielo ---------------------------------------------------------------------
plane{<0,1,0>,1 hollow
texture{ pigment{ bozo turbulence 0.99
color_map { [0.5 rgb <0.30, 0.30, 1.0>*1]
[0.6 rgb <1,1,0.9>]
[1.0 rgb <0.2,0.2,0.2>]}
scale 3.5 translate<10,0,9>
}
finish {ambient 1 diffuse 0} }
scale 10000}
//--------------------------------------------------------------------------
//--------------------------------------------------------------------
plane{<0,1,0>, 0
texture{pigment{ rgb <0.2, 0.2, 0.2> }
normal { bumps 0.18 scale <1,0.25,0.35>*1 turbulence 0.8 }
finish { ambient 0.05 diffuse 0.55
brilliance 6.0 phong 0.8 phong_size 120
reflection 0.6 }
}
}
//--------------------------------------------------------------------
#declare Asta_H = 1.75;
#declare Asta_R = 0.20;
#declare Asta = // Oggetto
union{
cylinder {<0,-Asta_H,0>,<0,Asta_H,0>,Asta_R translate<0,0,0>
texture{pigment{spiral1 2
color_map{[0.0 White]
[0.5 White]
[0.5 rgb<1,0.5,0>]
[1.0 rgb<1,0.5,0>]}
rotate<90,0,0>
scale<1,0.3,1>}
normal {bumps 0.3 scale 0.025}
finish {ambient 0.05 diffuse 0.95
phong 1 reflection 0.05}
}
}
union{
cylinder{<0,-0.05,0>,<0,0.05,0>,Asta_R+0.05 translate<0,Asta_H.0>}
sphere {<0,0,0>,Asta_R+0.05 translate<0,Asta_H+0.1,0> }
torus {1.0,0.1 scale 0.12 translate<0,Asta_H+0.01,0>}
texture{pigment{color White}
normal {bumps 0.3 scale 0.025}
finish {ambient 0.15 diffuse 0.85 phong 1 reflection 0.05}}}
}// fine di Asta --------
//---------------------------------------------------------------------
object{Asta scale 1 rotate<0,0,2> translate <-1.0,0,3>}
//----------------------------------------------------------------- fine
domenica 21 settembre 2014
A simple POV Ray file
This is a simple demonstration of a POV Ray file, written example.
// PoVRay 3.7 Scene File " Prato.pov"
// author: Max
// date: 13 September 2014
//--------------------------------------------------------------------------
#version 3.7;
global_settings{ assumed_gamma 1.0 }
#default{ finish{ ambient 0.1 diffuse 0.9 }}
//--------------------------------------------------------------------------
#include "colors.inc"
#include "textures.inc"
//#include "glass.inc"
//#include "metals.inc"
//#include "golds.inc"
//#include "stones.inc"
#include "woods.inc"
#include "shapes.inc"
#include "shapes2.inc"
//#include "functions.inc"
#include "math.inc"
//#include "transforms.inc"
#include "skies.inc"
//--------------------------------------------------------------------------
// camera ------------------------------------------------------------------
#declare Camera_0 = camera {/*ultra_wide_angle*/ angle 75 // front view
location <0.0 , 1.0 ,-3.0>
right x*image_width/image_height
look_at <0.0 , 1.0 , 0.0>}
#declare Camera_1 = camera {/*ultra_wide_angle*/ angle 90 // diagonal view
location <2.0 , 4.5 ,-3.0>
right x*image_width/image_height
look_at <0.0 , 1.0 , 0.0>}
#declare Camera_2 = camera {/*ultra_wide_angle*/ angle 90 // right side view
location <3.0 , 1.0 , 0.0>
right x*image_width/image_height
look_at <0.0 , 1.0 , 0.0>}
#declare Camera_3 = camera {/*ultra_wide_angle*/ angle 90 // top view
location <0.0 , 3.0 ,-0.001>
right x*image_width/image_height
look_at <0.0 , 1.0 , 0.0>}
camera{Camera_1}
// sun ---------------------------------------------------------------------
light_source{<-1500,2000,-2500> color White}
// sky ---------------------------------------------------------------------
sky_sphere{ S_Cloud4 // 1 - 5
scale 1
} //end of skysphere
//--------------------------------------------------------------------------
// fog ---------------------------------------------------------------------
fog{ fog_type 2
distance 50
color White*0.5
fog_offset 0.1
fog_alt 2.0
turbulence 0.8
} // end of fog
//--------------------------------------------------------------------------
// fog on the ground -------------------------------------------------
fog { fog_type 2
distance 50
color White
fog_offset 0.1
fog_alt 1.5
turbulence 1.8
}
// ground ------------------------------------------------------------
plane { <0,1,0>, 0
texture{ pigment{ color rgb<0.35,0.65,0.0>*0.72 }
normal { bumps 0.75 scale 0.015 }
finish { phong 0.1 }
} // end of texture
} // end of plane
//--------------------------------------------------------------------------
//---------------------------- objects in scene ----------------------------
//--------------------------------------------------------------------------
union {
object{ // Wire_Box(A, B, WireRadius, UseMerge)
Wire_Box(<-1,-0.15,-1>,<1,2,1>, 0.075 , 0)
texture{ pigment{ hexagon color White color Blue color Red }
finish { diffuse 0.9 phong 1 }
rotate<60,0,0> scale 0.05 translate<0,0,0>
} // end of texture
scale 1 rotate<0, 0,0> translate<0,0.1,0>
} // ---------------------------------------------
object{
box {<-0.95,-0.10,-0.95>,<0.95,1.95,0.95>}
texture{ T_Wood1
normal { wood 0.5 scale 0.05}
finish { phong 1 }
rotate<0,0, 0> scale 0.5
} // end of texture ------------------------
scale 1 rotate<0, 0,0> translate<0,0.1,0>
} // ------
}
The result is the picture showed below.
domenica 14 settembre 2014
A new book
I've started a new book around C++ and the POV Ray program, I'm learning in these days. During the next weeks I'll post my findings and pictures related to ray tracing and application on the C++ language as a tto to extend the functionality of the POV Ray program.
sabato 8 febbraio 2014
Libro pubblicato
Ho provveduto a pubblicare su Lulu.com il libro nel quale sono raccolte le considerazioni, e i post scritti in questo blog sulla programmazione C++. Il libro è disponibile al seguente collegamento ipertestuale:
http://www.lulu.com/spotlight/MaxShire
In formato Ebook con immagini.
http://www.lulu.com/spotlight/MaxShire
In formato Ebook con immagini.
lunedì 13 gennaio 2014
Efficienza
Alcune persone ritengono
che le ottimizzazioni premature per un sistema sono la radice di ogni
male. Al contrario, l'efficienza deve essere tenuta a mente durante
gli sforzi di progettazione ed implementazione. Comunque non
significa che il progettista deve preoccuparsi delle micro
efficienze, ma deve considerare l'efficienza di primo ordine. La
migliore strategia per produrre efficienza è la pulizia e una
progettazione semplice. Solo questo tipo di progettazione può
rimanere relativamente stabile durante il ciclo di vita del progetto,
e serve da base alla calibrazione delle performance. Evitare il
gigantismo che si nota nei progetti di grandi dimensioni è
essenziale. Troppo spesso le persone aggiungono delle funzioni “solo
in caso che”, e finiscono per duplicare o quadruplicare le
dimensioni del programma, ed il tempo di esecuzione ne soffre. La
cosa peggiore è che sistemi troppo elaborati, sono difficili da
analizzare, e diventa difficile distinguere le componenti evitabili
da quelle inevitabili. Quindi l'analisi di base e l'ottimizzazione
viene scoraggiata. L'ottimizzazione deve essere il risultato delle
analisi e delle misure delle performance, non una modifica a caso del
codice. Specialmente per sistemi di grandi dimensioni le intuizioni
del programmatore o del progettista non fanno da guida per
l'efficienza del sistema. E' importante evitare costruzioni
inefficienti di per sé, e attenzione nell'ottimizzare un livello
accettabile di performance. Similarmente, è importante minimizzare
l'uso di costrutti e programmi non portabili, in quanto condannano il
programma ad essere eseguito su vecchi (meno potenti e/o più
costosi) computer.
sabato 4 gennaio 2014
Manutenzione del software
La parola “manutenzione” è fuorviante in quanto
suggerisce un'analogia con l'hardware; ma il software non ha bisogno
di essere lubrificato, né vi sono parti in movimento che si usurano,
o vi sono crepe nelle quali l'acqua possa accumularsi, e fare
ruggine. Il software può essere copiato esattamente, ed inviato a
lunga distanza con un costo quasi nullo.
Le attività che sono note come manutenzione del
software sono in realtà
ri-progettazioni e re-implementazioni che avvengono durante il normale
ciclo di sviluppo. Quando la flessibilità, l'estensione e la
portabilità sono enfatizzate durante la progettazione, le sorgenti
tradizionali dei problemi di manutenzione sono coinvolti
direttamente.
Come i test, la
manutenzione non deve essere ritardata o separata dallo sviluppo
principale del sistema. In particola, è importante avere una certa
continuità nel gruppo di persone coinvolte nel progetto. Non è
facile trasferire la manutenzione ad un gruppo di persone nuove che
non hanno avuto collegamenti con i progettisti e gli sviluppatori
originali. Quando sono necessari cambiamenti di grandi dimensioni, ci
deve essere enfasi nel trasferire le conoscenze e la comprensione
della struttura del sistema attuale alle nuove persone coinvolte. Se
la “squadra manutenzione” si domanda quale sia l'architettura del
sistema e vien lasciata da sola a domandarsi come debbano essere
fatte le modifiche e la loro implementazione, la struttura si
deteriora rapidamente sotto il peso delle nuove patch
locali. La documentazione tipicamente deve includere i dettagli
necessari per aiutare le nuove persone a comprendere le idee ed i
principi chiave.
Iscriviti a:
Post (Atom)



