GENERIC VILLA
ITA Institute of Technology in Architecture / Faculty of Architecture / ETH Zurich / Chair for CAAD / Prof. Dr. Ludger Hovestadt
GENERIC VILLA artifacts for living
“Put the immanence of the global to the universal reference of the artifact. Then, create a new immanence out of that! This is the inversion and the negation of the every to get the any. This is the movement. This is the way of thinking. It is universal.”
supervisors : Ludger Hovestadt, Vera Bühlman assistant : Hua Hao
Melina Mezari, Stelios Psaltis
2012
bibliography 4
- Rowe C., The Mathematics of the Ideal Villa and Other Essays, MIT Press, Cambridge, 1987 - Davies C., Key House of the Twentieth Century, Laurence King Publishing Ltd, London, 2006 - Baudrillard J., The System of Objects (Radical Thinkers), Verso, London, 1996 - Simondon G, On the Mode of Existence of Technical Objects, Aubier, Editions Montaigne, Paris, 1958 - Simondon G., Interact or Die! Technical Individualization, Joke Brouwer & Arjen Mulder, Rotterdam , 2007 - Banham R., The Architecture of the Well - Tepered Environment, University of Chicago Press, Chicago, 1969 - Cache B., Earth Moves: The Furnishing of Territories, MIT Press, Cambridge, 1995 - Foucault M., Of Other Spaces, Diacritics 16, Spring 1986, 22-27
The notion of villa seems to be of extreme interest once again when related to the question of urbanity today. Villas were always related to political issues of power, signifying the power over a certain region.
The approach could be also considered as an experiment to universalize the notion and the principle of villa. As the whole of the planet is urbanized today, and we don’t really have any distinction between countryside and city, everybody who lives somewhere has a certain position in the community in which he/she behaves and acts. That way everyone has and expresses this kind of power relations. A way, would be to consider the engendering of villa, the unit in this global urbanity, as the generic villa which can be engendered specifically and individually.
So, the focus would be in what way this notion gets meaning by meaningful articulations or constellation of independent elementarized compartments - universal and generic ones. Certain configuration of this universal pieces-objects /related to activities, are able to express the specificallity and individuality of any villa.
By inclusion and inversion of the reference level of the objects-activities, in the final artifact we can define this and not the other villa.
5
expression impression
impression expression
expression
Following the iconic examples representing major architectural manifestoes through history, is obser
of progress, of expanding, but rather, one of a constant and symmetrical inversion of the body of think expression - impression
It is not the concrete structure of the automobile engine that is expressed but rather the form, color, shape, the accessories, and the "social standing" of the object. Here we have the tower of Babel: each item speaks its own idiom
The conservative, in choosing and using a car, wishes to convey such ideas as dignity, reserve, maturity, seriousness ... Another definite series of automotive personalities is selected by the people wanting 6
to make known their middle-of-the-road moderation, their being fashionable ... Further along the range of personalities are the innovators and the ultramodern...� No doubt Martineau is right: it is in this way that people define themselves in relation to objects. baudrillard
? impression
impression
ved that they don’t narrate a story
king. A mirrored symmetry between
7
what is the next villa?
Manufactured objects conspicuously transform into unexpected new forms, making a strong statement about our current cultural condition of abundance. Attention is focused on reconsideration of the ordinary.
8
Storytelling consists a vector
The storytelling concerns everyday stories within different houses. The main steps of our storytelling:
i_ every villa narrates a certain story which consists the villa’s vector
ii_ Starting with the objective functional compartments We engender the elementarization of the villa. Each villa is represented as a constellation of independent elementarized compartments, able to express its individuality.
iii_ creating symbolic stories about daily domestic objects Meaningful articulations / constellations of independent elementarized compartments. Overlaying and densification of pre-functional objects.
iv_ new species with new natures emerge, concluding in non-objective functional structures,
that rather spell out a notion of a villa. The object looses its objective functionality and become just a form(ation) carrying a certain potential activity. Universalize the principle of villa - as a unit in the global urbanity, the generic villa can be engendered specifically and individually.
9
10
THE VILLA an encapsulated symbolic nature
11
the house
12
Key villas as an encapsulation of symbolic stories. Within a frame of inclusion, the dom
level different stories take place and become meaningful according to a certain enviro as independent stories of actual villas.
as a field of operations
mestic object itself becomes contextualised with the others. Moving in a symbolic
onment. Within a certain constellation with the others, specific vectors are expressed
13
002_double house
001_double house
003_hanselmann house
004_glass block wall - horiuchi house
W
009_dominiguez house
010_aluminium house
F
008_vanna venturi house
007_rudolph apar tment
F
006_hanselmann house
005_eshrick house
011_glass block wall - horiuchi house
012_newton road
013_newton road
14
014_weissenhof house
F
015_zuber house
F
F
016_melnikov house
017_villa stein de monzie
018_vanna venturi house
020_E 1027
021_newton road
F
019_double house
022_eshrick house
023_E 1027
024_casa ugale
025_villa busk
Space takes the form of relations among sites. 15
026_casa rotunda
027_villa savoye
0 2 8 _ s c h m i n ke h o u s e
F
029_house at santander
031_jacobs house F
030_zuber house
F
035_lina bo bardi house
032_villa dall’ ava
033_house at santander
034_schroder house
036_aluminium house
037_casa ugale
F
039_casa rotunda
040_house at regensburg
F
0 3 8 _ f a t h e r ’s h o u s e
16
042_pavillon de l’ esprit nouveau 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
041_villa stein - de monzie
043_hopkins house
044_eames house
045_behrens house
For all their multiplicity, objects are generally isolated as to their function. It is the user who is responsible for their coexistence in a functional context; Their coexistence resembles an assortment of partial functions that are often irrelevant or antagonistic to one another. baudrillard
046_lovell beach house
047_casa rotunda
17
048_tugendhat house
049_villa dall’ ava
13 x 0.215
F
= 2.800
050_schroder house
051_roof roof house
052_villa dall’ ava
053_house at regensburg
056_fisher house
055_double house
0 5 7 _ f a t h e r ’s h o u s e
054_behrens house
F
058_casa ugalde
059_villa stein - de monzie
Causal relations enable the functioning of the elements. These relations or recurrent causality between the forms, are constituted by the associated milieu, which mediates the relation between the elements. simondon 18
061_fisher house
062_pavillon de l’ esprit nouveau 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
060_aluinaire house
st
063_winton guest house
064_neuendof house
065_roof roof house
066_rudolph apar tment
068_glass block wall - horiuchi house
067_villa stein de monzie house
069_hopkins house
Forms exist as separate entities and become active when they organize themselves in relation to the ground -the mental associated milieu, thus actualizing prior virtualities. simondon
071_neuendof house
072_villa stein de monzie house
F
F
070_double house
19
20
A bed is a bed, a chair is a chair, and there is no relationship between them so long as each serves only the function it is supposed to serve. baudrillard
Without such a relationship there can be no space, for space exists only when it is opened up, animated, invested with rythm and expanded by a correlation between objects and a transcendence of their functions in this new structure. In a way space is the object’s true freedom. baudrillard
21
The object looses its objective functionality and becomes just an index carrying a certain potential activity.
ε0.01
ε0.02
ε0.03
ε0.04
ε1.37
ε1.38
ε1.39
ε1.40
ε0.05
ε0.06
ε0.07
ε0.08
ε1.41
ε1.42
ε1.43
ε1.44
ε0.09
ε0.10
ε0.11
ε0.12
ε1.45
ε1.46
ε1.47
ε1.48
ε1.01
ε1.02
ε1.03
ε1.04
ε1.49
ε1.50
ε1.51
ε1.05
ε1.06
ε1.07
ε1.08
ε2.01
ε2.02
ε2.03
ε1.09
ε1.10
ε1.11
ε1.12
ε2.05
ε2.06
ε2.07
ε2.08
ε2.09
ε2.10
ε2.11
ε2.12
ε2.15
ε2.16
ε1.13
ε1.17
ε1.14
ε1.15
ε1.16
ε2.04
ε1.18
ε1.19
ε1.20
ε2.13
ε2.14
ε1.21
ε1.22
ε1.23
ε1.24
ε2.17
ε2.18
ε1.25
ε1.26
ε1.27
ε1.28
ε2.21
ε2.18
ε1.29
ε1.30
ε1.31
ε1.32
ε3.01
ε3.02
ε3.03
ε3.04
ε1.33
ε1.34
ε1.35
ε1.36
ε3.06
ε3.07
ε3.08
22
ε3.05
ε2.19
ε2.20
ε3.09
ε3.10
ε3.11
ε3.12
ε9.01
ε9.02
ε9.03
ε9.04
ε3.13
ε3.14
ε3.15
ε3.16
ε9.05
ε9.06
ε9.07
ε9.08
ε3.17
ε3.18
ε3.19
ε3.20
ε9.09
ε9.10
ε9.11
ε10.01
ε10.02
ε10.03
ε10.04
ε10.06
ε10.07
ε10.08
ε10.10
ε10.12
ε11.01
ε11.02
ε11.03
ε11.04
ε11.05
ε11.06
ε11.07
ε11.08
ε3.21
ε4.01
ε4.02
ε4.05
ε4.06
ε5.01
ε5.02
ε4.03
ε4.04
ε10.05
ε10.09
ε5.03
ε5.04
ε5.05
ε10.11
23 ε6.01
ε6.02
ε6.03
ε11.09
ε11.10
ε11.11
ε11.12
ε7.01
ε7.02
ε7.03
ε11.13
ε11.14
ε11.15
ε11.16
ε8.02
ε8.03
ε8.04
ε12.01
ε12.02
ε12.03
ε12.04
ε8.05
ε8.06
ε8.07
ε12.05
ε12.06
ε12.07
ε12.08
ε8.01
24
Different geometries, attributes, activities, potentials blend, accord
In the second stage of selecting - exluding indexes new architectur Compose all the functional compartments in a way to get a vector,
ding to certain vectors. New artifacts produced by infused indexes.
ral, formal and functional qualities emerge. that once again is the justification of the whole previous stage.
25
26
THE next VILLA an inhabitable artifact
27
Principal Component Analysis (PCA) Principal component analysis (PCA) is a mathematical procedure that uses an orthogonal transformation to convert a set of observations of possibly correlated variables into a set of values of linearly uncorrelated variables called principal components. The number of principal components is less than or equal to the number of original variables. This transformation is defined in such a way that the first principal component has the largest possible variance (that is, accounts for as much of the variability in the data as possible), and each succeeding component in turn has the highest variance possible under the constraint that it be orthogonal to (i.e., uncorrelated with) the preceding components. Principal components are guaranteed to be independent only if the data set is jointly normally distributed. PCA is sensitive to the relative scaling of the original variables. PCA was invented in 1901 by Karl Pearson. Now it is mostly used as a tool in exploratory data analysis and for making predictive models. PCA can be done by eigenvalue decomposition of a data covariance (or correlation) matrix or singular value decomposition of a data matrix, usually after mean centering (and normalizing or using Z-scores) the data matrix for each attribute. The results of a PCA are usually discussed in terms of component scores, sometimes called factor scores (the transformed variable values corresponding to a particular data point), and loadings (the weight by which each standardized original variable should be multiplied to get the component score). PCA is the simplest of the true eigenvector-based multivariate analyses. Often, its operation can be thought of as revealing the internal structure of the data in a way that best explains the variance in the data. If a multivariate dataset is visualised as a set of coordinates in a high-dimensional data space (1 axis per variable), PCA can supply the user with a lower-dimensional picture, a “shadow” of this object when viewed from its (in some sense) most informative viewpoint. This is done by using only the first few principal components so that the dimensionality of the transformed data is reduced. PCA is mathematically defined as an orthogonal linear transformation that transforms the data to a new coordinate system such that the greatest variance by any projection of the data comes to lie on the first coordinate (called the first principal component), the second greatest variance on the second coordinate, and so on.
28
Given a set of points in Euclidean space, the first principal component corresponds to a line that passes through the multidimensional mean and minimizes the sum of squares of the distances of the points from the line. The second principal component corresponds to the same concept after all correlation with the first principal component has been subtracted from the points. The singular values (in Σ) are the square roots of the eigenvalues of the matrix XXT. Each eigenvalue is proportional to the portion of the “variance” (more correctly of the sum of the squared distances of the points from their multidimensional mean) that is correlated with each eigenvector. The sum of all the eigenvalues is equal to the sum of the squared distances of the points from their multidimensional mean. PCA essentially rotates the set of points around their mean in order to align with the principal components. This moves as much of the variance as possible (using an orthogonal transformation) into the first few dimensions. The values in the remaining dimensions, therefore, tend to be small and may be dropped with minimal loss of information. PCA is often used in this manner for dimensionality reduction. PCA has the distinction of being the optimal orthogonal transformation for keeping the subspace that has largest “variance” (as defined above). PCA is sensitive to the scaling of the variables. If we have just two variables and they have the same sample variance and are positively correlated, then the PCA will entail a rotation by 45° and the “loadings” for the two variables with respect to the principal component will be equal. But if we multiply all values of the first variable by 100, then the principal component will be almost the same as that variable, with a small contribution from the other variable, whereas the second component will be almost aligned with the second original variable. One way of making the PCA less arbitrary is to use variables scaled so as to have unit variance.
Applying Principal Component Analysis
Along the same line of thought, in this experimental approach, a process of thinking towards the challenging question -of what a next villa might be, is investigated. PCA codes are used and explored as the main tool in architectural design.
Initially, floorplans from 20th century villas are selected as input data. The input floorplans are placed in relative position, having a domestic object as a common point of reference. The output is a number of eigen floorplans, equal to the number of input images. The difference between the eigen-floorplans depends on which floorplan is defined as the “first principal component�. In that way different focal points define the overall setup of these arrangements and rearrange all the included constellations, and consequently, all the possible stories. Since all of them are projected to a new coordinate system, they gain new meaning and content. At this stage the eigen floorplans express new values and unforeseen stories.
On a second stage, from a potentially infinite number of eigen floorplans, certain constellations are selected and produced in three dimensional models. The main purpose of that is to create real hybrids that would encapsulate a variety of different stories within a high dimensionality artefact. This high dimensionality is achieved by fusing the input data (the individualized internal compartments) in a series of generations. By containing certain percentages of the input data, different kind of geometries (but always within the same boundaries of the 3d space) merging together, synthesizing new meanings.
29
technical steps - coding process
In technical terms, the whole process follows the steps below:
i_ arranging certain setups of a specific constellation A certain constellation is defined by an eigen floorplan. A number of unprocessed input data placed accordingly in a single bounding box, by using a 3d modelling software (in this case Rhino).
ii_ converting the input geometries to voxelized geometries and to one dimensional numerical array lists the input geometries are converted to voxelized ones, defined by an one dimensional numerical array list. This is necessary in order to proceed to the eigen calculations, as the code requires all the input data in the form of one dimensional numerical array list. code: _001_VOXELISING
iii_ extracting the exact values that, according to the eigen transformation, display the original geometry. code: _002_WEIGHTS
iv_ applying eigen transformations according to certain controllable atractors areas of 100% representation of original geometries, and areas of blending between them, are defined. The output geometry is rendered as a voxelized one, out of the new one dimensional array, taken from the eigen calculation. code: _003_EIGEN_TRANSFORMATION_Z
v_ looping and repeating the steps, producing generations with increasingly dimensionality 30
every new eigen geometry, produced in the series of previous steps, is combined with new unprocessed input data, or other eigen geometries. Following this process, infinite number of generations could be produced, resulting to combinatorial endlessness.
The displayed geometries are just few examples that could be extracted from a whole universe of potential artefacts.
reference codes: EigenFace, MarixMath
_001_VOXELISING 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69.
package _00_THESIS_PROJECT; import processing.core.PApplet; import processing.core.PApplet; import processing.core.PVector; import saito.objloader.BoundingBox; import saito.objloader.OBJModel; import peasy.*; import java.io.PrintWriter; public class _001_VOXELIZING extends PApplet { // size of voxels int sizeOfVoxels = 10; // input path for bounding box String bBoxPath = "C:/Users/STELIOS/Desktop/test_input/00_bbox/BOX.obj"; // input path for geometry String geomPath = "C:/Users/STELIOS/Desktop/test_input/01_obj/"; // the name of the object String nameOfObject = "ARMCHAIR_07"; // without ".obj" // path for saving the txt file String txtPath = "C:/Users/STELIOS/Desktop/test_input/02_txt/"; // path for exporting geometry String dxfPath = "C:/Users/STELIOS/Desktop/test_input/04_dxf/" + nameOfObject; boolean exportDXF = false; // output path for saving the txt file String finalTxtPath = txtPath + nameOfObject + ".txt"; String finalGeomPath = geomPath + nameOfObject + ".obj"; PrintWriter output; PeasyCam cam; OBJModel modelBbox; OBJModel model; BoundingBox bbox; float maxX; float maxY; float maxZ; float minX; float minY; float minZ; int numberOfVoxelsX; int numberOfVoxelsY; int numberOfVoxelsZ; // creating a 3d array for voxels _0001_E_Voxel[][][] voxelGrid; // defining variable for center points of the voxels PVector centerPointsVector; PVector[] centerPointsArray; // FOR VERTEXES int numberOfVertexes; PVector[] vertexesArray; int xCor; int yCor; int zCor; PVector[] flooredVertexesArray; PVector[] geomPointsArray; int index; int xy;
31
_001_VOXELISING 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96. 97. 98. 99. 100. 101. 102. 103. 104. 105. 106. 107. 108. 109. 110. 111. 112. 113. 114. 115. 116. 117. 118. 32 119. 120. 121. 122. 123. 124. 125. 126. 127. 128. 129. 130. 131. 132. 133. 134. 135. 136. 137. 138.
int counter; // FOR DISTANCES float[][] distances; float[] minDistanceArray; public void setup() { size(600, 400, P3D); cam = new PeasyCam(this, 1000); // loading the bounding box modelBbox = new OBJModel(this, bBoxPath); modelBbox.enableDebug(); // loading the geometry model = new OBJModel(this, finalGeomPath); model.enableDebug(); bbox = new BoundingBox(this, modelBbox); // calculating the max and the min values of the boundingBox maxX = bbox.getMax().x; maxY = bbox.getMax().y; maxZ = bbox.getMax().z; minX = bbox.getMin().x; minY = bbox.getMin().y; minZ = bbox.getMin().z; numberOfVoxelsX = floor((maxX - minX) / sizeOfVoxels) + 1; numberOfVoxelsY = floor((maxY - minY) / sizeOfVoxels) + 1; numberOfVoxelsZ = floor((maxZ - minZ) / sizeOfVoxels) + 1; xy = numberOfVoxelsX * numberOfVoxelsY; // initializing all the arrays voxelGrid = new _0001_E_Voxel[numberOfVoxelsZ][numberOfVoxelsY][numberOfVoxelsX]; centerPointsArray = new PVector[numberOfVoxelsX * numberOfVoxelsY * numberOfVoxelsZ]; flooredVertexesArray = new PVector[numberOfVoxelsX * numberOfVoxelsY * numberOfVoxelsZ]; // create the voxel grid int count = 0; for (int z = 0; z < voxelGrid.length; z++) { for (int y = 0; y < voxelGrid[z].length; y++) { for (int x = 0; x < voxelGrid[z][y].length; x++) { _0001_E_Voxel myVoxel = voxelGrid[z][y][x]; centerPointsVector = new PVector(x * sizeOfVoxels - abs(minX), y * sizeOfVoxels - abs(minY), z * sizeOfVoxels - abs(minZ)); // this is strange centerPointsArray[count] = centerPointsVector; count++; } } } println("size of voxels = " + sizeOfVoxels); println("centerPointsArray.length = " + centerPointsArray.length); // FOR VERTEXES // getting the number of vertexes numberOfVertexes = model.getVertexCount(); vertexesArray = new PVector[numberOfVertexes]; // find all the vertexes for (int i = 0; i < numberOfVertexes; i++) { vertexesArray[i] = model.getVertex(i); } // step_1 // floor their cordinates and find their index in the 1D array
_001_VOXELISING 139. 140. 141. 142. 143. 144. 145. 146. 147. 148. 149. 150. 151. 152. 153. 154. 155. 156. 157. 158. 159. 160. 161. 162. 163. 164. 165. 166. 167. 168. 169. 170. 171. 172. 173. 174. 175. 176. 177. 178. 179. 180. 181. 182. 183. 184. 185. 186. 187. 188. 189. 190. 191. 192. 193. 194. 195. 196. 197. 198. 199. 200. 201. 202. 203. 204. 205. 206. 207.
// feed this array with these indexes for (int i = 0; i < vertexesArray.length; i++) { xCor = floor(vertexesArray[i].x / sizeOfVoxels); yCor = floor(vertexesArray[i].y / sizeOfVoxels); zCor = floor(vertexesArray[i].z / sizeOfVoxels); PVector a = new PVector(xCor * sizeOfVoxels, yCor * sizeOfVoxels, zCor * sizeOfVoxels); index = ((yCor * numberOfVoxelsX) + xCor) + (zCor * xy); }
flooredVertexesArray[index] = a;
// step_2 // calculate the number of the geometries new points - voxels counter = 0; for (int i = 0; i < flooredVertexesArray.length; i++) { if (flooredVertexesArray[i] != null) { counter++; } } // step_3 // initialize this array with the previous number geomPointsArray = new PVector[counter]; // step_4 // fill this array with 3d points - vectors count = 0; for (int i = 0; i < flooredVertexesArray.length; i++) { if (flooredVertexesArray[i] != null) { PVector a = new PVector(flooredVertexesArray[i].x, flooredVertexesArray[i].y, flooredVertexesArray[i].z); geomPointsArray[count] = a; count++; } } println("geomPointsArray.length = " + geomPointsArray.length); // step_5 // measuring all the distances from every voxel of the bounding box distances = new float[centerPointsArray.length][geomPointsArray.length]; minDistanceArray = new float[centerPointsArray.length]; for (int i = 0; i < centerPointsArray.length; i++) { for (int j = 0; j < geomPointsArray.length; j++) { // distances[i][j] = centerPointsOfAllVoxels[i] // .dist(mainCenterPoints[j]); distances[i][j] = centerPointsArray[i].dist(geomPointsArray[j]); } } // step_6 // loop through all thevoxels and collect the min distances for (int i = 0; i < centerPointsArray.length; i++) { minDistanceArray[i] = min(distances[i]); } println("minDistanceArray.length = " + minDistanceArray.length); // step_7 // saving the txt file output = createWriter(finalTxtPath); for (int i = 0; i < minDistanceArray.length; i++) { output.println(minDistanceArray[i]); output.flush(); // Writes the remaining data to the file } output.close(); // Finishes the file
33
_001_VOXELISING 208. 209. 210. 211. 212. 213. 214. 215. 216. 217. 218. 219. 220. 221. 222. 223. 224. 225. 226. 227. 228. 229. 230. 231. 232. 233. 234. 235. 236. 237. 238. 239. 240. // 241. 242. 243. 244. 245. 246. 247. 248. 249. 250. 251. 252. 253. 254. 255. 256. 34 257. 258. 259. 260. }
}
println("EVERYTHING IS DONE!");
public void draw() { background(255); lights(); noFill(); stroke(0); bbox.draw(); stroke(255, 0, 0); line(0, 0, 0, 100, 0, 0); stroke(0, 255, 0); line(0, 0, 0, 0, 100, 0); fill(200); noStroke(); // model.draw(); // just a preview of something. NOT NECESSARY! // DXF if (exportDXF == true) { beginRaw(DXF, dxfPath + ".dxf"); // Start recording to the file } for (int i = 0; i < geomPointsArray.length; i++) { pushMatrix(); stroke(0); translate(geomPointsArray[i].x, geomPointsArray[i].y, geomPointsArray[i].z); box(sizeOfVoxels, sizeOfVoxels, sizeOfVoxels); point(0, 0, 0); popMatrix(); }
}
if (exportDXF == true) { endRaw(); exportDXF = false; // Stop recording to the file println("SUCESSFULLY EXPORTED AS DXF"); }
public void keyPressed() { if (key == 'n' || key == 'N') { save(second() + ".png"); } if (key == 'e' || key == 'E') { // Press R to save the file exportDXF = true; } }
35
_002_WEIGHTS 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 36 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69.
package _00_THESIS_PROJECT; import java.io.File; import java.io.PrintWriter; import controlP5.ControlP5; import controlP5.ControlWindow; import controlP5.Slider; import _01_PEIGEN_FACE.EigenFace; import _01_PEIGEN_FACE.MatrixMath; import processing.core.PApplet; import peasy.PeasyCam; import saito.objloader.BoundingBox; import saito.objloader.OBJModel; public class _002_WEIGHTS extends PApplet { // CHANGE ONLY THESE // HERE THE PATH TO READ TXT FROM (SOS! PUT / AT THE END) int sizeOfVoxels = 10; // SIZE OF VOXELS! (according to the previews code) String inputPath = “C:/Users/STELIOS/Desktop/test_input/02_txt/”; String bBoxPath = “C:/Users/STELIOS/Desktop/test_input/00_bbox/BOX.obj”; // path to save the weights / save them by pressing ‘s’ String saveWeightsPath = “C:/Users/STELIOS/Desktop/test_input/03_weights/”; // index of element to extract weights int indexOfElement = 2; // DO NOT CHANGE FROM HERE ON File folder = new File(inputPath); File[] files = folder.listFiles(); int numberOfFiles = files.length; int selectedNumOfEigenFaces = numberOfFiles; // FOR EIGEN EigenFace face; float theWeight0; float theWeight1; float theWeight2; // for weights double[] weights; public double[] offsets; int selectNumOfEigenFaces = numberOfFiles; public double[][] getWeights; // for aytoWeights double[] autoWeights; int indexOfObject; double[] data; String[][] lines; double[][] allDistances; int zCor; int yCor; int xCor; int xy; int xyz; PeasyCam cam; ControlP5 controlP5; ControlWindow controlWindow; float distanceRange; float range; String nameOfElement; // FOR BOUNDING BOX OBJModel model; BoundingBox bbox;
_002_WEIGHTS 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96. 97. 98. 99. 100. 101. 102. 103. 104. 105. 106. 107. 108. 109. 110. 111. 112. 113. 114. 115. 116. 117. 118. 119. 120. 121. 122. 123. 124. 125. 126. 127. 128. 129. 130. 131. 132. 133. 134. 135. 136. 137. 138.
float minX; float minY; float minZ; float maxX; float maxY; float maxZ; float dimX; float dimY; float dimZ; int numberOfVoxelsX; int numberOfVoxelsY; int numberOfVoxelsZ; public void setup() { size(960, 540, P3D); rectMode(CENTER); cam = new PeasyCam(this, 1000); ui(); controlP5.setAutoDraw(false); controlP5.addSlider(“distanceRange”, 0, 255, 40, 40, 100, 10); for (int i = 0; i < numberOfFiles; i++) { nameOfElement = files[indexOfElement].getName(); } // FOR BOUNDING BOX model = new OBJModel(this, bBoxPath); model.enableDebug(); bbox = new BoundingBox(this, model); // calculating the max and the min values of every boundingBoxes maxX = bbox.getMax().x; maxY = bbox.getMax().y; maxZ = bbox.getMax().z; minX = bbox.getMin().x; minY = bbox.getMin().y; minZ = bbox.getMin().z; // finding the dimensions of the overall boundingBox dimX = maxX - minX; dimY = maxY - minY; dimZ = maxZ - minZ; // finding the number of voxels for every dimension numberOfVoxelsX = (int) (dimX / sizeOfVoxels) + 1; numberOfVoxelsY = (int) (dimY / sizeOfVoxels) + 1; numberOfVoxelsZ = (int) (dimZ / sizeOfVoxels) + 1; println(numberOfVoxelsX); println(numberOfVoxelsY); println(numberOfVoxelsZ); xy = numberOfVoxelsX * numberOfVoxelsY; xyz = numberOfVoxelsX * numberOfVoxelsY * numberOfVoxelsZ; lines = new String[numberOfFiles][xyz]; allDistances = new double[numberOfFiles][xyz]; for (int a = 0; a < numberOfFiles; a++) { lines[a] = loadStrings(files[a]);
}
for (int i = 0; i < lines[a].length; i++) { // float f = Float.valueOf(str).floatValue(); allDistances[a][i] = Float.valueOf(lines[a][i]).floatValue(); }
// FOR EIGEN face = new EigenFace();
37
_002_WEIGHTS 139. 140. 141. 142. 143. 144. 145. 146. 147. 148. 149. 150. 151. 152. 153. 154. 155. 156. 157. 158. 159. 160. 161. 162. 163. 164. 165. 166. 167. 168. 169. 170. 171. 172. 173. 174. 175. 176. 177. 178. 179. 180. 181. 182. 183. 184. 185. 186. 187. 38 188. 189. 190. 191. 192. 193. 194. 195. 196. 197. 198. 199. 200. 201. 202. 203. 204. 205. 206. 207.
face.initEigenfaces(allDistances); int nEigenfaces = selectNumOfEigenFaces; // for weights weights = new double[nEigenfaces]; getWeights = new double[numberOfFiles][nEigenfaces]; // for autoWeights // OBJModel weightsObject = model[indexOfObject]; data = new double[allDistances[indexOfElement].length]; for (int i = 0; i < allDistances[indexOfElement].length; i++) { float m = (float) allDistances[indexOfElement][i]; data[i] = m; } autoWeights = face.getWeightsByData(data, selectedNumOfEigenFaces);
}
println(“”); println(“autoWeights:”); println(“for element “ + indexOfElement + “ / “ + nameOfElement + “:”); println(autoWeights);
public void draw() { background(255); lights(); translate(0, 0, 0); // for weights weights[0] = autoWeights[0] + theWeight0; weights[1] = autoWeights[1] + theWeight1; weights[2] = autoWeights[2] + theWeight2; double[] result = get3DByWeights(weights, selectNumOfEigenFaces); for (int i = 0; i < xyz; i++) { zCor = floor(i / xy); yCor = floor((i - (zCor * xy)) / (numberOfVoxelsX)); xCor = floor((i - (zCor * xy)) - (yCor * numberOfVoxelsX)); // for preview only the voxelized object if (result[i] < distanceRange) { fill(200); stroke(0); pushMatrix(); translate(xCor * sizeOfVoxels, yCor * sizeOfVoxels, zCor * sizeOfVoxels); // point(0, 0, 0); box(sizeOfVoxels, sizeOfVoxels, sizeOfVoxels); popMatrix(); }
} noFill(); stroke(0); bbox.draw();
stroke(255, 0, 0); line(0, 0, 0, 100, 0, 0); stroke(0, 255, 0); line(0, 0, 0, 0, 100, 0); } public double[] get3DByWeights(double[] weights, int selectedeigenfaces) { double[][] egnfacesSubMatrix = MatrixMath.getSubMatrix(face.eigenFaces, 0, selectedeigenfaces); double[] geometryData = MatrixMath.multiply(weights, egnfacesSubMatrix); geometryData = MatrixMath.add(geometryData, face.dataAverage); return geometryData; }
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
208. 209. 210. 211. 212. 213. 214. 215. 216. 217. 218. 219. 220. 221. 222. 223. 224. 225. 226. 227. 228. 229. 230. 231. 232. 233. 234. 235. 236. 237. 238. 239. 240. 241. 242. 243. 244. 245. 246. 247. 248. 249. 250. 251. 252. 253. 254. 255. 256. 257. 258. 259. 260. 261. 262. 263. }
_002_WEIGHTS void ui() {
controlP5 = new ControlP5(this); controlWindow = controlP5.addControlWindow(“distanceRange”, 100, 100, 1100, 120); Slider s01 = controlP5
.addSlider(“distanceRange”, 0, 50, 22, 20, 500, 5); s01.setWindow(controlWindow); Slider s02 = controlP5.addSlider(“range”, 0, 50, 22, 40, 500, 5); s02.setWindow(controlWindow); Slider s03 = controlP5.addSlider(“theWeight0”, -130000, 130000, 22, 60, 1000, 5); s03.setWindow(controlWindow); Slider s04 = controlP5.addSlider(“theWeight1”, -130000, 130000, 22, 80, 1000, 5); s04.setWindow(controlWindow);
}
Slider s05 = controlP5.addSlider(“theWeight2”, -130000, 130000, 22, 100, 1000, 5); s05.setWindow(controlWindow);
public void keyPressed() { float a = (float) (autoWeights[0] + theWeight0); float b = (float) (autoWeights[1] + theWeight1); float c = (float) (autoWeights[2] + theWeight2); if (key == ‘w’ || key == ‘W’) { println(“”); println(“”); println(“FINAL WEIGHTS”); println(“for element “ + indexOfElement + “ / “ + nameOfElement + “:”); println(“weight[0] = “ + a); println(“weight[1] = “ + b); println(“weight[2] = “ + c); } if (key == ‘s’ || key == ‘S’) { Object output = createWriter(saveWeightsPath + indexOfElement + “ - “ + nameOfElement); ((PrintWriter) output).println(“for element “ + indexOfElement + “ / “ + nameOfElement + “:”); ((PrintWriter) output).println(“weight[0] = “ + a); ((PrintWriter) output).println(“weight[1] = “ + b); ((PrintWriter) output).println(“weight[2] = “ + c);
}
}
((PrintWriter) output).flush(); // Writes the remaining data to the file ((PrintWriter) output).close(); // Finishes the file
39
_ 003_EIGEN_TRANSFORMATION_Z 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 40 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69.
package _00_THESIS_PROJECT; import java.io.File; import java.io.PrintWriter; import java.util.ArrayList; import controlP5.ControlP5; import controlP5.ControlWindow; import controlP5.Slider; import _01_PEIGEN_FACE.EigenFace; import _01_PEIGEN_FACE.MatrixMath; import processing.core.PApplet; import processing.core.PVector; import peasy.PeasyCam; import saito.objloader.BoundingBox; import saito.objloader.OBJModel; import processing.dxf.*; public class _003_EIGEN_TRANSFORMATION_Z extends PApplet { // voxels int sizeOfVoxels = 10; // SIZE OF VOXELS! (according to the previews code) // HERE THE PATH TO READ TXT FROM (SOS! PUT / AT THE END) String inputPath = “C:/Users/STELIOS/Desktop/test_input/02_txt/”; // for ounding box String bBoxPath = “C:/Users/STELIOS/Desktop/test_input/00_bbox/BOX.obj”; // path for exporting geometry String dxfPath = “C:/Users/STELIOS/Desktop/test_input/04_dxf/eigenDxf”; PVector[] pointCloud; RawDXF dxf; boolean exportDXF = false; PrintWriter output; boolean record; int frameRec = 1; File folder = new File(inputPath); File[] files = folder.listFiles(); int numberOfFiles = files.length; PeasyCam cam; ControlP5 controlP5; ControlWindow controlWindow; float distanceRange; float range; // FOR EIGEN EigenFace face; float theWeight1; float theWeight2; float theWeight3; // for weights double[] weights; public double[] offsets; int selectNumOfEigenFaces = numberOfFiles; public double[][] getWeights; int numberOfObjects = numberOfFiles; float theWeight0_a = (float) -165965.55; float theWeight1_a = (float) -5287.9976; float theWeight2_a = (float) -31543.85; float theWeight0_b = (float) -30962.61; float theWeight1_b = (float) -13842.358; float theWeight2_b = (float) 31556.887;
_003_EIGEN_TRANSFORMATION_Z 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96. 97. 98. 99. 100. 101. 102. 103. 104. 105. 106. 107. 108. 109. 110. 111. 112. 113. 114. 115. 116. 117. 118. 119. 120. 121. 122. 123. 124. 125. 126. 127. 128. 129. 130. 131. 132. 133. 134. 135. 136. 137. 138.
float theWeight0_c = (float) 199788.16; float theWeight1_c = (float) -22469.645; float theWeight2_c = (float) -31733.037; float m0_a_b; float m1_a_b; float m2_a_b; float m0_b_c; float m1_b_c; float m2_b_c; double[][] geomArray_a_b; double[][] geomArray_b_c; double[][] geomArrayFor_a; double[][] geomArrayFor_b; double[][] geomArrayFor_c; double[] result; int q = 0; String[][] lines; double[][] allDistances; int zCor; int yCor; int xCor; int xy; int xyz; int attractor_a; int heightAttractor_a; int previewAttractor_a; int attractor_b_high; int heightAttractor_b_high; int previewAttractor_b_high; int attractor_b_low; int heightAttractor_b_low; int previewAttractor_b_low; int attractor_c; int heightAttractor_c; int previewAttractor_c; // FOR BOUNDING BOX OBJModel model; BoundingBox bbox; float minX; float minY; float minZ; float maxX; float maxY; float maxZ; float dimX; float dimY; float dimZ; int numberOfVoxelsX; int numberOfVoxelsY; int numberOfVoxelsZ; float centerOfBoxX; float centerOfBoxY; float centerOfBoxZ; public void setup() {
41
_ 003_EIGEN_TRANSFORMATION_Z 139. 140. 141. 142. 143. 144. 145. 146. 147. 148. 149. 150. 151. 152. 153. 154. 155. 156. 157. 158. 159. 160. 161. 162. 163. 164. 165. 166. 167. 168. 169. 170. 171. 172. 173. 174. 175. 176. 177. 178. 179. 180. 181. 182. 183. 184. 185. 186. 187. 188. 42 189. 190. 191. 192. 193. 194. 195. 196. 197. 198. 199. 200. 201. 202. 203. 204. 205. 206. 207.
// noLoop(); size(600, 400, P3D); rectMode(CENTER); cam = new PeasyCam(this, 2000); ui(); controlP5.setAutoDraw(false); controlP5.addSlider(“distanceRange”, 0, 255, 40, 40, 100, 10); // --------------------------------------------- > // FOR BOUNDING BOX model = new OBJModel(this, bBoxPath); model.enableDebug(); bbox = new BoundingBox(this, model); // calculating the max and the min values of every boundingBoxes maxX = bbox.getMax().x; maxY = bbox.getMax().y; maxZ = bbox.getMax().z; minX = bbox.getMin().x; minY = bbox.getMin().y; minZ = bbox.getMin().z; // finding the center point of the overall boundingBox centerOfBoxX = maxX - (maxX - minX) / 2; centerOfBoxY = maxY - (maxY - minY) / 2; centerOfBoxZ = maxZ - (maxZ - minZ) / 2; // finding the dimensions of the overall boundingBox dimX = maxX - minX; dimY = maxY - minY; dimZ = maxZ - minZ; // finding the number of voxels for every dimension numberOfVoxelsX = (int) (dimX / sizeOfVoxels) + 1; numberOfVoxelsY = (int) (dimY / sizeOfVoxels) + 1; numberOfVoxelsZ = (int) (dimZ / sizeOfVoxels) + 1; xy = numberOfVoxelsX * numberOfVoxelsY; xyz = numberOfVoxelsX * numberOfVoxelsY * numberOfVoxelsZ; lines = new String[numberOfFiles][xyz]; allDistances = new double[numberOfFiles][xyz]; for (int a = 0; a < numberOfFiles; a++) { lines[a] = loadStrings(files[a]);
}
for (int i = 0; i < lines[a].length; i++) { // float f = Float.valueOf(str).floatValue(); allDistances[a][i] = Float.valueOf(lines[a][i]).floatValue(); }
// FOR EIGEN face = new EigenFace(); face.initEigenfaces(allDistances); int nEigenfaces = selectNumOfEigenFaces; // for weights weights = new double[nEigenfaces]; getWeights = new double[numberOfObjects][nEigenfaces]; geomArrayFor_a = new double[numberOfVoxelsZ][1]; geomArrayFor_b = new double[numberOfVoxelsZ][1]; geomArrayFor_c = new double[numberOfVoxelsZ][1]; weights = new double[nEigenfaces]; println(“start a”); // creating Z number of eigens of 100% a for (int a = 0; a < numberOfVoxelsZ; a++) { weights[0] = theWeight0_a; weights[1] = theWeight1_a; weights[2] = theWeight2_a; geomArrayFor_a[a] = get3DByWeights(weights, selectNumOfEigenFaces); }
_003_EIGEN_TRANSFORMATION_Z 208. 209. 210. 211. 212. 213. 214. 215. 216. 217. 218. 219. 220. 221. 222. 223. 224. 225. 226. 227. 228. 229. 230. 231. 232. 233. 234. 235. 236. 237. 238. 239. 240. 241. 242. 243. 244. 245. 246. 247. 248. 249. 250. 251. 252. 253. 254. 255. 256. 257. 258. 259. 260. 261. 262. 263. 264. 265. 266. 267. 268. 269. 270. 271. 272. 273. 274. 275. 276.
println(“start b”); // creating Z number of eigens of 100% b for (int a = 0; a < numberOfVoxelsZ; a++) { weights[0] = theWeight0_b; weights[1] = theWeight1_b; weights[2] = theWeight2_b; geomArrayFor_b[a] = get3DByWeights(weights, selectNumOfEigenFaces); } println(“start c”); // creating Z number of eigens of 100% c for (int a = 0; a < numberOfVoxelsZ; a++) { weights[0] = theWeight0_c; weights[1] = theWeight1_c; weights[2] = theWeight2_c; geomArrayFor_c[a] = get3DByWeights(weights, selectNumOfEigenFaces); }
}
// initialize the array for collecting points pointCloud = new PVector[xyz];
public void draw() { // point cloud if (record) { output = createWriter(“F:/M8/08_SOFTIMAGE_FILES/colRec04/frame_” + frameRec + “.txt”); } // DXF if (exportDXF == true) { beginRaw(DXF, dxfPath + “.dxf”); // Start recording to the file } background(255); lights(); translate(0, 0, 0); // for attractors attractor_a = floor(heightAttractor_a / sizeOfVoxels); previewAttractor_a = (attractor_a * sizeOfVoxels) - (sizeOfVoxels / 2); attractor_b_high = floor(heightAttractor_b_high / sizeOfVoxels); previewAttractor_b_high = (attractor_b_high * sizeOfVoxels) - (sizeOfVoxels / 2); attractor_b_low = floor(heightAttractor_b_low / sizeOfVoxels); previewAttractor_b_low = (attractor_b_low * sizeOfVoxels) - (sizeOfVoxels / 2); attractor_c = floor(heightAttractor_c / sizeOfVoxels); previewAttractor_c = (attractor_c * sizeOfVoxels) - (sizeOfVoxels / 2); // WEIGHTS FOR VOXEL SIZE 30 theWeight0_a = (float) -165965.55; theWeight1_a = (float) -5287.9976; theWeight2_a = (float) -31543.85; theWeight0_b = (float) -30962.61; theWeight1_b = (float) -13842.358; theWeight2_b = (float) 31556.887; theWeight0_c = (float) 199788.16; theWeight1_c = (float) -22469.645; theWeight2_c = (float) -31733.037; m0_a_b = (theWeight0_a - theWeight0_b) / (attractor_a - attractor_b_high); m1_a_b = (theWeight1_a - theWeight1_b) / (attractor_a - attractor_b_high); m2_a_b = (theWeight2_a - theWeight2_b) / (attractor_a - attractor_b_high);
43
_ 003_EIGEN_TRANSFORMATION_Z 277. 278. 279. 280. 281. 282. 283. 284. 285. 286. 287. 288. 289. 290. 291. 292. 293. 294. 295. 296. 297. 298. 299. 300. 301. 302. 303. 304. 305. 306. 307. 308. 309. 310. 311. 312. 313. 314. 315. 316. 317. 318. 319. 320. 321. 322. 323. 324. 325. 44 326. 327. 328. 329. 330. 331. 332. 333. 334. 335. 336. 337. 338. 339. 340. 341. 342. 343. 344. 345.
m0_b_c = (theWeight0_b - theWeight0_c) / (attractor_b_low - attractor_c); m1_b_c = (theWeight1_b - theWeight1_c) / (attractor_b_low - attractor_c); m2_b_c = (theWeight2_b - theWeight2_c) / (attractor_b_low - attractor_c); // creating Z number of eigens for transition geomArray_a_b = new double[attractor_a - attractor_b_high][1]; geomArray_b_c = new double[attractor_b_low - attractor_c][1]; // println(“start eigen”); // filling the array between a - b for (int a = 0; a < (attractor_a - attractor_b_high); a++) { weights[0] = theWeight0_b + m0_a_b; weights[1] = theWeight1_b + m1_a_b; weights[2] = theWeight2_b + m2_a_b; theWeight0_b = theWeight0_b + m0_a_b; theWeight1_b = theWeight1_b + m1_a_b; theWeight2_b = theWeight2_b + m2_a_b; }
geomArray_a_b[a] = get3DByWeights(weights, selectNumOfEigenFaces);
// filling the array between b - c for (int a = 0; a < (attractor_b_low - attractor_c); a++) { weights[0] = theWeight0_c + m0_b_c; weights[1] = theWeight1_c + m1_b_c; weights[2] = theWeight2_c + m2_b_c; theWeight0_c = theWeight0_c + m0_b_c; theWeight1_c = theWeight1_c + m1_b_c; theWeight2_c = theWeight2_c + m2_b_c; }
geomArray_b_c[a] = get3DByWeights(weights, selectNumOfEigenFaces);
// gather the points / voxels in tha array pointCloud pointCloud = new PVector[xyz]; // emptying the array // preview the 100% of a int counter_1 = 0; int count = 0; for (int a = attractor_a; a < numberOfVoxelsZ; a++) { for (int i = a * xy; i < (xy + (a * xy)); i++) { zCor = floor(i / xy); yCor = floor((i - (zCor * xy)) / (numberOfVoxelsX)); xCor = floor((i - (zCor * xy)) - (yCor * numberOfVoxelsX));
}
} count ++;
if (geomArrayFor_a[count][i] < distanceRange) { PVector v = new PVector(xCor * sizeOfVoxels, yCor * sizeOfVoxels, zCor * sizeOfVoxels); pointCloud[counter_1] = v; counter_1++; }
// preview eigen between a - b int counter_2 = counter_1; count = 0; for (int a = attractor_b_high; a < attractor_a; a++) { for (int i = a * xy; i < (xy + (a * xy)); i++) { zCor = floor(i / xy); yCor = floor((i - (zCor * xy)) / (numberOfVoxelsX)); xCor = floor((i - (zCor * xy)) - (yCor * numberOfVoxelsX)); if (geomArray_a_b[count][i] < distanceRange) {
_003_EIGEN_TRANSFORMATION_Z 346. 347. 348. 349. 350. 351. 352. 353. 354. 355. 356. 357. 358. 359. 360. 361. 362. 363. 364. 365. 366. 367. 368. 369. 370. 371. 372. 373. 374. 375. 376. 377. 378. 379. 380. 381. 382. 383. 384. 385. 386. 387. 388. 389. 390. 391. 392. 393. 394. 395. 396. 397. 398. 399. 400. 401. 402. 403. 404. 405. 406. 407. 408. 409. 410. 411. 412. 413. 414.
}
} count++;
}
PVector v = new PVector(xCor * sizeOfVoxels, yCor * sizeOfVoxels, zCor * sizeOfVoxels); pointCloud[counter_2] = v; counter_2++;
// preview the 100% of b int counter_3 = counter_2; count = 0; for (int a = attractor_b_low; a < attractor_b_high; a++) { for (int i = a * xy; i < (xy + (a * xy)); i++) { zCor = floor(i / xy); yCor = floor((i - (zCor * xy)) / (numberOfVoxelsX)); xCor = floor((i - (zCor * xy)) - (yCor * numberOfVoxelsX));
}
} count++;
if (geomArrayFor_b[count][i] < distanceRange) { PVector v = new PVector(xCor * sizeOfVoxels, yCor * sizeOfVoxels, zCor * sizeOfVoxels); pointCloud[counter_3] = v; counter_3++; }
// preview eigen between b - c int counter_4 = counter_3; count = 0; for (int a = attractor_c; a < attractor_b_low; a++) { for (int i = a * xy; i < (xy + (a * xy)); i++) { zCor = floor(i / xy); yCor = floor((i - (zCor * xy)) / (numberOfVoxelsX)); xCor = floor((i - (zCor * xy)) - (yCor * numberOfVoxelsX));
}
} count++;
if (geomArray_b_c[count][i] < distanceRange) { PVector v = new PVector(xCor * sizeOfVoxels, yCor * sizeOfVoxels, zCor * sizeOfVoxels); pointCloud[counter_4] = v; counter_4++; }
// preview the 100% of c int counter_5 = counter_4; count = 0; for (int a = 0; a < attractor_c; a++) { for (int i = a * xy; i < (xy + (a * xy)); i++) { zCor = floor(i / xy); yCor = floor((i - (zCor * xy)) / (numberOfVoxelsX)); xCor = floor((i - (zCor * xy)) - (yCor * numberOfVoxelsX));
}
} count++;
if (geomArrayFor_c[count][i] < distanceRange) { PVector v = new PVector(xCor * sizeOfVoxels, yCor * sizeOfVoxels, zCor * sizeOfVoxels); pointCloud[counter_5] = v; counter_5++; }
45
_ 003_EIGEN_TRANSFORMATION_Z 415. 416. 417. 418. 419. 420. 421. 422. 423. 424. 425. 426. 427. 428. 429. 430. 431. 432. 433. 434. 435. 436. 437. 438. 439. 440. 441. 442. 443. 444. 445. 446. 447. 448. 449. 450. 451. 452. 453. 454. 455. 456. 457. 458. 459. 460. 461. 462. 463. 464. 46 465. 466. 467. 468. 469. 470. 471. 472. 473. 474. 475. 476. 477. 478. 479. 480. 481. 482. 483.
// draw the points / voxels for (int i = 0; i < pointCloud.length; i++) { if (pointCloud[i] != null) { pushMatrix(); translate(pointCloud[i].x, pointCloud[i].y, pointCloud[i].z); // point(0, 0, 0); box(sizeOfVoxels, sizeOfVoxels, sizeOfVoxels); popMatrix();
}
}
// save frames for softImage if (record) { output.println(pointCloud[i].x / sizeOfVoxels + “ “ + pointCloud[i].y / sizeOfVoxels + “ “ + pointCloud[i].z / sizeOfVoxels); }
if (exportDXF == true) { endRaw(); exportDXF = false; // Stop recording to the file println(“SUCESSFULLY EXPORTED AS DXF”); } if (record) {
} void ui() {
}
output.flush(); output.close(); println(“RECORDING! FRAME: “ + frameRec); frameRec++; // to save only one frame. For more delete it record = false;
controlP5 = new ControlP5(this); controlWindow = controlP5.addControlWindow(“distanceRange”, 100, 100, 1300, 150); Slider s01 = controlP5.addSlider(“distanceRange”, 0, 100, 22, 20, 500, 5); s01.setWindow(controlWindow); Slider s02 = controlP5.addSlider(“heightAttractor_a”, 0, 2500, 22, 40, 1000, 5); s02.setWindow(controlWindow); Slider s03 = controlP5.addSlider(“heightAttractor_b_high”, 0, 2500, 22, 60, 1000, 5); s03.setWindow(controlWindow); Slider s04 = controlP5.addSlider(“heightAttractor_b_low”, 0, 2500, 22, 80, 1000, 5); s04.setWindow(controlWindow);
}
Slider s05 = controlP5.addSlider(“heightAttractor_c”, 0, 2500, 22, 100, 1000, 5); s05.setWindow(controlWindow);
public double[] get3DByWeights(double[] weights, int selectedeigenfaces) { double[][] egnfacesSubMatrix = MatrixMath.getSubMatrix(face.eigenFaces, 0, selectedeigenfaces); double[] geometryData = MatrixMath.multiply(weights, egnfacesSubMatrix); geometryData = MatrixMath.add(geometryData, face.dataAverage); return geometryData; } public void keyPressed() {
_003_EIGEN_TRANSFORMATION_Z 484. 485. 486. 487. 488. 489. 490. 491. 492. 493. 494. 495. }
if (key == ‘n’ || key == ‘N’) { save(second() + “.png”); }
}
if (key == ‘E’ || key == ‘e’) { // Press R to save the file exportDXF = true; } if (key == ‘r’ || key == ‘R’) { record = !record; }
47
EigenFace 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 48 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69.
package _01_PEIGEN_FACE; /* Packages cern.colt* , cern.jet*, cern.clhep Copyright (c) 1999 CERN - European Organization for Nuclear Research. Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. CERN makes no representations about the suitability of this software for any purpose. It is provided â&#x20AC;&#x153;as isâ&#x20AC;? without expressed or implied warranty. */ import java.util.Collections; import java.util.Vector; import cern.colt.matrix.impl.DenseDoubleMatrix2D; import cern.colt.matrix.linalg.EigenvalueDecomposition; public class EigenFace { public double[][] eigenFaces; public double[] dataAverage; public double[][] dataDifference; public void initEigenfaces(double[][] dataSet) { // difference from average dataAverage = MatrixMath.getAverage(dataSet); dataDifference = MatrixMath.subtractFromRows(dataSet, dataAverage); // covarianzmatrix double[][] mN = MatrixMath.multiply(dataDifference, MatrixMath.transpose(dataDifference)); // eigenvaluedecomosition from cern DenseDoubleMatrix2D d = new DenseDoubleMatrix2D(mN); EigenvalueDecomposition e = new EigenvalueDecomposition(d); double[] eigenValues = MatrixMath.diag(e.getD().toArray()); double[][] eigenVectors = e.getV().viewDice().toArray();
}
// sorting Vector<EigenPair> eigenPairs = new Vector<EigenPair>(); for (int i = 0; i < eigenValues.length; i++) { EigenPair ep = new EigenPair(eigenValues[i], eigenVectors[i]); eigenPairs.add(ep); } Collections.sort(eigenPairs); for (int i = 0; i < eigenPairs.size(); i++) { EigenPair ep = eigenPairs.get(i); eigenValues[i] = ep.eigenValue; eigenVectors[i] = ep.eigenVector; } eigenFaces = MatrixMath.multiply(eigenVectors, dataDifference); eigenFaces = MatrixMath.normalizeRows(eigenFaces);
public double[] getWeights(double[] data, int selectedeigenfaces) { data = MatrixMath.subtract(data, dataAverage); // finding weights.. double[][] eigenFacesMatrixPart = MatrixMath.getSubMatrix(eigenFaces, 0, selectedeigenfaces); double[][] eigenFacesMatrixPartTranspose = MatrixMath .transpose(eigenFacesMatrixPart); double[] inputWtsArray = MatrixMath.multiply(data, eigenFacesMatrixPartTranspose);// single array return inputWtsArray; } public class EigenPair implements Comparable<EigenPair> { double eigenValue;
EigenFace 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96.
double[] eigenVector; public EigenPair(double eigenValue, double[] eigenVector) { this.eigenValue = eigenValue; this.eigenVector = eigenVector; }
}
}
public int compareTo(EigenPair other) { if (eigenValue > other.eigenValue) return -1; return 1; }
// FOR WEIGHTS public double[] getWeightsByData(double[] data, int selectedeigenfaces) { data = MatrixMath.subtract(data, dataAverage); // finding weights.. double[][] eigenFacesMatrixPart = MatrixMath.getSubMatrix(eigenFaces, 0, selectedeigenfaces); double[][] eigenFacesMatrixPartTranspose = MatrixMath .transpose(eigenFacesMatrixPart); double[] inputWtsArray = MatrixMath.multiply(data, eigenFacesMatrixPartTranspose);// single array return inputWtsArray; }
49
MatrixMath 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 50 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69.
package _01_PEIGEN_FACE; public class MatrixMath { public static double getDistanceSqr(double[] v1,double[] v2){ double sum=0; for (int i=0;i<v1.length;i++){ double cD=v1[i]-v2[i]; sum+=cD*cD; } return sum; } public static double getDistance(double[] v1,double[] v2){ double dsqr=getDistanceSqr(v1,v2); return Math.sqrt(dsqr); } public static double[] getCol(double[][] v,int iCol){ double[] col = new double[v.length]; for (int i = 0; i < v.length; i++) { col[i] = v[i][iCol]; } return col; } public static double[][] multiply(double[][] v1, double[][] v2){ double[][] result = new double[v1.length][v2[0].length]; for (int i = 0; i < result.length; i++) { for (int j = 0; j < result[i].length; j++) { // sum of i-row of a and j-col of b double[] row = v1[i]; double[] col = getCol(v2,j); double sum = 0; for (int ii = 0; ii < row.length; ii++) { sum += row[ii] * col[ii]; } result[i][j] = sum; } } return result; } public static double[] multiply(double[] v1, double[][] v2){ double[] result = new double[v2[0].length]; for (int j = 0; j < result.length; j++) { // sum of i-row of a and j-col of b double[] col = getCol(v2,j); double sum = 0; for (int ii = 0; ii < v1.length; ii++) { sum += v1[ii] * col[ii]; } result[j] = sum; } return result;
} public static double[] multiplyElementWise(double[] v1,double[]v2){ double[] result=new double[v1.length]; for (int i=0;i<v1.length;i++){ result[i]=v1[i]*v2[i]; } return result;
} public static double[][] multiplyElementWise(double[][] v1,double[][]v2){ double[][] result=new double[v1.length][v1[0].length]; for (int i=0;i<v1.length;i++){ for (int j=0;j<v1[0].length;j++){ result[i][j]=v1[i][j]*v2[i][j];
MatrixMath 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96. 97. 98. 99. 100. 101. 102. 103. 104. 105. 106. 107. 108. 109. 110. 111. 112. 113. 114. 115. 116. 117. 118. 119. 120. 121. 122. 123. 124. 125. 126. 127. 128. 129. 130. 131. 132. 133. 134. 135. 136. 137. 138.
}
} } return result;
public static double[] subtract(double[] v1,double[] v2){ double[] result=new double[v1.length]; for (int i = 0; i < result.length; i++) { result[i]=v1[i] - v2[i]; } return result; } public static double[] add(double[] v1,double[] v2){ double[] result=new double[v1.length]; for (int i = 0; i < result.length; i++) { result[i]=v1[i] + v2[i]; } return result; } public static double[][] subtractFromRows(double[][] values,double[] a) { double[][] result=new double[values.length][values[0].length]; for (int i = 0; i < values.length; i++) { result[i]=subtract(values[i], a); } return result; } public static double[][] transpose(double[][] values) { double[][] swapValues = new double[values[0].length][values.length]; for (int x = 0; x < values.length; x++) { for (int y = 0; y < values[x].length; y++) { swapValues[y][x] = values[x][y]; } } }
return swapValues;
public static double[][] normalise(double[][] v ) { double[][] result=new double[v.length][v[0].length]; double[] mvals = new double[v.length]; for (int i = 0; i < v.length; i++) { mvals[i] = max(v[i]); } for (int i = 0; i < v.length; i++) { for (int j = 0; j < v[0].length; j++) { result[i][j]=v[i][j] / mvals[i]; } } return result; } public static double min(double[][] arr) { double m = Double.MAX_VALUE; for (int i = 0; i < arr.length; i++) { m =min(arr[i]); } return m; } public static double min(double[] arr) { double m = Double.MAX_VALUE; for (int i = 0; i < arr.length; i++) { m = Math.min(m, arr[i]); } return m; } public static double max(double[][] arr) { double m = Double.NEGATIVE_INFINITY; for (int i = 0; i < arr.length; i++) {
51
MatrixMath 139. 140. 141. 142. 143. 144. 145. 146. 147. 148. 149. 150. 151. 152. 153. 154. 155. 156. 157. 158. 159. 160. 161. 162. 163. 164. 165. 166. 167. 168. 169. 170. 171. 172. 173. 174. 175. 176. 177. 178. 179. 180. 181. 182. 183. 184. 185. 186. 187. 188. 52 189. 190. 191. 192. 193. 194. 195. 196. 197. 198. 199. 200. 201. 202. 203. 204. 205. 206. 207.
} return m;
//m = max(arr[i]); m = Math.max(m,max(arr[i]));
} public static double max(double[] arr) { double m = Double.NEGATIVE_INFINITY; for (int i = 0; i < arr.length; i++) { m = Math.max(m, arr[i]); } return m; } public static double mag(double[] oneDArray) { double val = 0.0; for (int i = 0; i < oneDArray.length; i++) { val += (oneDArray[i] * oneDArray[i]); } return Math.sqrt(val); } public static double[] flatten(double[][] values) { double[] res = new double[values.length * values[0].length]; int i = 0; for (int r = 0; r < values.length; r++) { for (int c = 0; c < values[0].length; c++) { res[i] = values[r][c]; i++; } } return res; } public static double[] getAverage(double[][] values) { double[] average = new double[values[0].length]; for (int i = 0; i < values[0].length; i++) { double sum = 0; for (int ii = 0; ii < values.length; ii++) { sum += values[ii][i]; } average[i] = sum / values.length; } return average; } public static double[] normalizeLength(double[] values){ double[] result=new double[values.length]; double l = mag(values); for (int i=0;i<result.length;i++){ result[i]=values[i]/l; } return result; } public static double[][] normalizeRows(double[][] values) { double[][] result=new double[values.length][values[0].length]; for (int i = 0; i < values.length; i++) { result[i]= normalizeLength(values[i]); } return result; } public static double[][] getSubMatrix(double[][] values,int row1, int row2) { double[][] newValues = new double[row2 - row1][]; for (int i = row1; i < row2; i++) { newValues[i] = values[i]; } return newValues; } public static double[] getSubMatrix(double[] values,int row1, int row2) { double[] newValues = new double[row2 - row1]; for (int i = row1; i < row2; i++) {
MatrixMath 208. 209. 210. 211. 212. 213. 214. 215. 216. 217. 218. 219. 220. 221. 222. 223. 224. 225.
newValues[i] = values[i]; } return newValues;
} public static double[] diag(double[][] m) { double[] d = new double[m.length]; for (int i = 0; i < m.length; i++) d[i] = m[i][i]; return d; }
public static void print(double[] values){ for (int i=0;i<values.length;i++){ System.out.println(â&#x20AC;&#x153;i: â&#x20AC;&#x153;+values[i]); } } }
53
impression - image
All the objective functional needs diffused in an artifact with a greater degree of cohe
The objects lose their symbolic naturalness, order and achieve a higher degree of abs
54
What are the best axis to classify the variants of these data within an abstract floorplan?
to synthesize new content
erence. Activities are inserted into a matrix of objects and be merged together.
strctness, as they are liberated from their function.
55
one could describe via its network of relations, the :
eigen00
56
.dining room
57
f( 001 012 014 015 017 018 023 025 029 030 031 032 035 039 043 047 048 050 059 060 061 063 069 076 077 078 079 080 081 082 083 086 089 091 093 100 104 106 )
eigen00
58
.bathroom
59
f( 001 012 014 015 017 018 023 025 029 030 031 032 035 039 041 042 043 044 045 046 047 048 049 050 051 052 057 058 059 060 061 062 063 064 066 069 076 077 078 079 080 081 082 083 084 086 089 091 092 093 096 097 099 100 104 105 106 )
eigen00
60
.master bedroom
61
f( 001 012 014 015 017 018 025 029 030 031 032 035 039 041 042 044 045 046 047 048 049 050 051 052 057 058 059 060 061 062 063 064 066 069 076 077 078 079 080 081 082 083 084 086 089 091 092 093 096 097 099 100 104 105 106 )
eigen00
62
.staircase
63
f( 001 012 014 015 017 018 023 025 029 030 031 032 035 039 043 047 048 050 059 060 061 063 069 076 077 078 079 080 081 082 083 086 089 091 093 096 097 099 100 104 106 )
eigen02
64
.staircase
eigen21
65
eigen27
66
.staircase
eigen43
67
eigen06
eigen07
eigen11
eigen012
eigen16
eigen17
eigen21
eigen22
68
.staircase
eigen08
eigen09
eigen13
eigen14
eigen18
eigen19
69
eigen23
eigen24
70
eigen26
eigen27
eigen31
eigen32
eigen36
eigen37
eigen41
eigen42
eigen46
.staircase
eigen47
eigen28
eigen29
eigen33
eigen34
eigen38
eigen39
eigen43
eigen44
eigen48
eigen49
71
eigen56
eigen57
eigen61
eigen62
eigen66
eigen67
72
.staircase
eigen58
eigen59
eigen63
eigen64
73
eigen68
eigen69
we elementarize until the degree that
By defining a certain vector through all these symbolic activities, an individua
74
the object can function as individual
al villa is engendered. The concluding doped artifacts create new identities.
75
ε(10.12 1.02)
ε(0.01 0.02 0.03)
ε(2.08 3.06 1.51)
ε(4.01 1.21)
ε(5.05 3.14)
ε(10.11 10.02)
ε(0.11 0.02 0.05)
ε(4.05 3.18)
ε(1.08 1.22 2.07)
ε(1.02 1.08)
ε(0.03 0.09)
ε(7.01 4.01)
ε(1.51 1.49)
ε(0.05 0.02)
ε(2.01 7.03)
76
ε(4.01 1.21 1.51)
ε(0.11 0.02 0.05)
ε(1.16 5.02 3.09)
ε(4.06 3.08 3.01)
ε(1.23 6.03)
ε(0.11 0.04)
ε(0.02 0.11 0.04)
ε(1.02 9.09)
ε(1.06 1.26 1.23)
77
ε(9.11 2.18)
ε(0.02 0.04)
ε(5.05 1.48 3.13)
ε(1.21 4.04 0.12)
ε(3.18 12.03 3.09)
F IRS T GEN ERAT ION
ε(7.02 4.01)
ε(0.08 0.09 0.06)
ε(1.06 1.26 1.23)
ε(2.18 9.06)
ε(10.01 1.48 3.13)
ε(5.02 3.14)
ε(0.04 0.07 0.01)
ε(0.02 0.04 0.11)
ε(1.16 4.05 5.05)
ε(1.08 6.02)
ε(3.19 5.05)
ε(0.12 3.09 5.04)
ε(4.01 10.12)
ε(2.19 4.04)
ε(3.16 1.51)
ε(1.02 1.08)
78
ε(6.01 8.06)
ε(2.19 4.04 )
ε(1.06 1.26 1.23)
ε(1.12 1.02)
ε(0.09 0.03)
ε(3.13 1.51 5.05)
ε(0.11 0.02 0.05)
ε(1.23 2.07)
ε(2.07 1.02)
79
ε(1.51 6.02)
ε(0.02 0.05)
ε(1.08 1.22 1.21)
ε(10.06 10.05)
ε(0.02 0.11 0.04)
F IRS T GEN ERAT ION
ε(4.05 7.02)
ε(1.28 5.05)
ε(0.04 0.09 0.03)
ε(2.07 1.22)
ε(3.13 4.01 1.21)
ε(1.51 1.49)
ε(4.06 3.08 3.01)
ε(0.02 0.04 0.11)
ε(3.20 3.21)
ε(0.12 0.04 0.11)
ε(1.33 12.08)
ε(0.07 0.03 0.02)
ε(1.16 4.01 3.18)
ε(0.01 0.10)
ε(10.01 1.04 6.03)
ε(3.07 10.06)
80
ε(1.02 1.18)
ε(1.06 1.26 1.23)
ε(0.08 0.09 0.06)
ε(2.07 2.17)
ε(3.13 1.51 5.05)
ε(2.18 9.06)
ε(0.05 0.02)
ε(2.07 1.02)
ε(0.02 0.04 0.11)
81
ε(3.09 1.16 )
ε(1.08 1.22 1.21)
ε(1.02 9.09)
ε(0.02 0.11 0.04)
ε(2.07 2.17)
F IRS T GEN ERAT ION
ε(1.06 1.26 1.23)
ε(2.19 4.04 )
ε(0.02 0.04)
ε(2.08 3.06 1.51)
ε(1.33 12.08)
ε(9.11 2.18)
ε(2.07 1.22)
ε(6.03 1.23 6.03)
ε(1.08 6.02 1.28)
ε(6.01 8.06)
ε(3.09 1.16 )
ε(0.03 0.09)
ε(3.13 4.01 1.21)
ε(1.23 6.03)
ε(1.28 5.05)
ε(0.04 0.09 0.03)
82
ε(2.08 3.06 1.51)
ε(0.08 0.09 0.06)
ε(3.13 1.51 5.05)
ε(0.03 0.09)
ε(4.05 7.02)
ε(0.08 0.09 0.06)
ε(1.16 4.05 5.05)
ε(0.11 0.02 0.05)
ε(1.08 1.22 2.07)
83
ε(1.02 1.08)
ε(3.18 12.03 3.09)
ε(4.01 1.21)
ε(0.04 0.09 0.03)
ε(0.04 0.09 0.03)
F IRS T GEN ERAT ION
ε(2.19 4.04 )
ε(1.12 1.02)(1.02 9.09)
ε(9.06 2.20)(7.02 4.01)
ε(0.05 0.02)(0.12 3.09 5.04)
ε(3.13 1.51 5.05)(1.08 1.22 2.07)
ε(1.16 4.01 3.18)(3.07 10.06)
ε(0.11 0.02 0.05)(3.13 1.51 5.05)
84
ε(0.08 0.09 0.06) (2.07 1.22)
ε(2.07 2.05)(2.08 3.06 1.51)
ε(0.11 0.02 0.05)(9.11 2.18)
ε(7.01 4.01)(4.01 7.02)
85
S ECON D GEN ERATION ε(9.06 2.20)(4.01 7.02)
ε(0.08 0.09 0.06) (0.08 0.09 0.06)
ε(5.05 1.48 3.13) (0.01 0.02 0.03) (5.02 3.14)
ε(4.01 7.02)(10.12 1.02)
ε(10.12 1.02)(1.02 9.09)
ε(0.08 0.09 0.06) (4.06 3.08 3.01)
ε(1.16 10.12)(5.05 1.48 3.13)
ε(0.11 0.02 0.05)(3.13 1.51 5.05)
86
ε(10.12 4.01)(9.11 6.01)
ε(10.12 4.01)(9.11 6.01)
ε(4.01 7.02)(7.03 2.02)
ε(7.01 4.01)(4.01 7.02)
87
S ECON D GEN ERATION ε(12.08 1.33)(2.03)
ε(2.07 1.02)(1.02 1.18)
ε(3.13 1.51 5.05)(1.08 1.22 2.07)
ε(2.07 1.02)(1.02 1.18)
ε(2.07 2.05)(2.08 3.06 1.51)
ε(0.05 0.02)(0.12 3.09 5.04)
ε(0.01 7.10)(2.19 4.04)
ε(10.12 1.02)(1.02 9.09)
88
ε(0.08 0.09 0.06) (0.08 0.09 0.06)
ε(1.16 10.12)(5.05 1.48 3.13)
ε(4.01 7.02)(7.03 2.02)
ε(0.08 0.09 0.06) (4.06 3.08 3.01)
89
S ECON D GEN ERATION ε(0.11 0.02 0.05)(9.11 2.18)
ε(5.05 1.48 3.13) (0.01 0.02 0.03) (5.02 3.14)
ε((0.01 7.10)(2.19 4.04)) (2.18 9.06) (1.02 1.08) (1.02 9.09) (0.08 0.09 0.06)
90
ε((0.01 7.10)(2.19 4.04)) (0.08 0.09 0.06) (1.02 9.09) (1.02 1.08) (10.12 1.02)
ε((0.01 7.10)(2.19 4.04)) (0.08 0.09 0.06) (1.21 4.04 0.12)
91
THIR D GEN ERAT ION ε((0.01 7.10)(2.19 4.04)) ((2.07 2.05)(2.08 3.06 1.51)) (2.18 9.06) (1.02 1.08) (1.02 9.09) (0.08 0.09 0.06)
ε((0.08 0.09 0.06) (4.06 3.08 3.01)) ((0.01 7.10)(2.19 4.04))
92
ε((0.11 0.02 0.05)(3.13 1.51 5.05)) (1.23 6.03) (0.12 3.09 5.04)
ε((0.08 0.09 0.06) (4.06 3.08 3.01)) ((0.01 7.10)(2.19 4.04))
93
THIR D GEN ERAT ION ε((0.01 7.10)(2.19 4.04)) (0.08 0.09 0.06) (1.02 9.09) (1.02 1.08) (10.12 1.02)
94
95
ε((0.01 7.10)(2.19 4.04)) (2.18 9.06) (1.02 1.08) (1.02 9.09) (0.08 0.09 0.06)
96
Îľ((0.01 7.10)(2.19 4.04)) ((2.07 2.05)(2.08 3.06 1.51)) (2.18 9.06) (1.02 1.08) (1.02 9.09) (0.08 0.09 0.06)
The overall object consists an artifact within which certain signals specify possible act
simplicity and effectiveness that code reveals. It formalizes a universal system of statu
Thus, the overall artifact offers abudance of choices for activities. Everything is there b
activities for certain areas. These phenomena propose increasing dimensionality of ac
97
Îľ((0.01 7.10)(2.19 4.04)) (0.08 0.09 0.06) (1.21 4.04 0.12)
tivities. It consists a system of signification but it lacks an active syntax. It has the
usses.
but nothing is defined. Certain symbols ,as parts of the initial inputs, specify possible THIR D GENERATION
ctivities and novel ways of dealing and inhabiting the space.
98
ε((0.01 7.10)(2.19 4.04)) ((2.07 2.05)(2.08 3.06 1.51)) (2.18 9.06) (1.02 1.08) (1.02 9.09) (0.08 0.09 0.06) ((0.05 0.02)(0.12 3.09 5.04)) (0.02 0.04)
FOU RT H G ENERAT ION
99
â&#x20AC;&#x153;no more beds for lying in, no more chairs for sitting at
102
103
- instead, “functional” objects that treat all positions and hence all human relationships”