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.

Here it is the first sample picture.


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.

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.