Menu
▾
▴
[Opengate-svn] SF.net SVN: opengate:[1082]
|
From: <Ult...@us...> - 2009-03-01 16:51:12
|
Revision: 1082
http://opengate.svn.sourceforge.net/opengate/?rev=1082&view=rev
Author: Ultrasick
Date: 2009-03-01 16:51:03 +0000 (Sun, 01 Mar 2009)
Log Message:
-----------
removing rotation buttons which showed up to be quite useless
+ adding functionality to draw a dummy texture
there are still bugs
Modified Paths:
--------------
branches/ogEditor/data/modules/texturizer/scripts/main/functions.py
branches/ogEditor/data/modules/texturizer/scripts/main/variables.py
branches/ogEditor/data/modules/texturizer/scripts/screens/project/canvas/frames/edit_the_face.py
branches/ogEditor/data/modules/texturizer/scripts/screens/project/new/frames/start_a_new_project.py
Removed Paths:
-------------
branches/ogEditor/data/modules/texturizer/graphic/buttons/edit_the_face/rotate_clockwise.png
branches/ogEditor/data/modules/texturizer/graphic/buttons/edit_the_face/rotate_counterclockwise.png
templates/branches/ogEditor/data/modules/texturizer/graphic/buttons/edit_the_face/rotate.pspimage
Deleted: branches/ogEditor/data/modules/texturizer/graphic/buttons/edit_the_face/rotate_clockwise.png
===================================================================
(Binary files differ)
Deleted: branches/ogEditor/data/modules/texturizer/graphic/buttons/edit_the_face/rotate_counterclockwise.png
===================================================================
(Binary files differ)
Modified: branches/ogEditor/data/modules/texturizer/scripts/main/functions.py
===================================================================
--- branches/ogEditor/data/modules/texturizer/scripts/main/functions.py 2009-03-01 16:02:46 UTC (rev 1081)
+++ branches/ogEditor/data/modules/texturizer/scripts/main/functions.py 2009-03-01 16:51:03 UTC (rev 1082)
@@ -1,7 +1,13 @@
# -*- coding: cp1252 -*-
import gobject
+from math import acos
+from math import cos
+from math import pi
+from math import sin
from math import sqrt
+from math import tan
+
#from os import listdir
#from os import path as check
#from os import system
Modified: branches/ogEditor/data/modules/texturizer/scripts/main/variables.py
===================================================================
--- branches/ogEditor/data/modules/texturizer/scripts/main/variables.py 2009-03-01 16:02:46 UTC (rev 1081)
+++ branches/ogEditor/data/modules/texturizer/scripts/main/variables.py 2009-03-01 16:51:03 UTC (rev 1082)
@@ -16,4 +16,8 @@
view_size = 250
view_x_position = 0
view_y_position = 0
-view_zoom = 1
\ No newline at end of file
+view_zoom = 1
+
+# resolutions (in pixels per meter)
+resolution_texture_map = 100
+resolution_normal_map = 100
\ No newline at end of file
Modified: branches/ogEditor/data/modules/texturizer/scripts/screens/project/canvas/frames/edit_the_face.py
===================================================================
--- branches/ogEditor/data/modules/texturizer/scripts/screens/project/canvas/frames/edit_the_face.py 2009-03-01 16:02:46 UTC (rev 1081)
+++ branches/ogEditor/data/modules/texturizer/scripts/screens/project/canvas/frames/edit_the_face.py 2009-03-01 16:51:03 UTC (rev 1082)
@@ -12,6 +12,98 @@
frame.add(table)
table.show()
+class geometry:
+ def get_angle(self, vector_1, vector_2):
+ # get the distances
+ distance_1 = self.get_distance(vector_1)
+ distance_2 = self.get_distance(vector_2)
+
+ # calculate the denominator
+ denominator = distance_1 * distance_2
+
+ # calculate the numerator
+ numerator = (vector_1[0] * vector_2[0]) + (vector_1[1] * vector_2[1]) + (vector_1[2] * vector_2[2])
+
+ # calculate the value of the fraction
+ fraction_value = numerator/denominator
+
+ if fraction_value>1:
+ fraction_value = 1
+
+ return acos(fraction_value)
+
+ def get_area(self, triangle):
+ # get the vectors
+ vector_1 = self.get_vector(triangle[0], triangle[1])
+ vector_2 = self.get_vector(triangle[0], triangle[2])
+
+ # calculate the area
+ area = self.get_distance(self.get_cross_product(vector_1, vector_2))/2
+
+ return area
+
+ def get_cross_product(self, vector_1, vector_2):
+ x = vector_1[1] * vector_2[2] - vector_1[2] * vector_2[1]
+ y = vector_1[2] * vector_2[0] - vector_1[0] * vector_2[2]
+ z = vector_1[0] * vector_2[1] - vector_1[1] * vector_2[0]
+
+ return [x, y, z]
+
+ def get_distance(self, vector):
+ return sqrt(vector[0] ** 2 + vector[1] ** 2 + vector[2] ** 2)
+
+ def get_plane(self, offset, vector_1, vector_2):
+ # create an array for the plane
+ plane = {}
+
+ # store the offset
+ plane['offset'] = offset
+
+ # create an array for the vectors
+ plane['vectors'] = []
+
+ # store the vectors
+ plane['vectors'].append(vector_1)
+ plane['vectors'].append(vector_2)
+
+ # return the plane
+ return plane
+
+ def get_triangles(self, vertices):
+ # check if there are only 3 vertices
+ if len(vertices)==3:
+ return [vertices]
+
+ # create an array for the triangles
+ triangles = []
+
+ # build triangles
+ triangles.append([vertices[0], vertices[1], vertices[2]])
+ triangles.append([vertices[2], vertices[3], vertices[0]])
+ triangles.append([vertices[1], vertices[2], vertices[3]])
+ triangles.append([vertices[3], vertices[0], vertices[1]])
+
+ if (self.get_area(triangles[0]) + self.get_area(triangles[1]))<(self.get_area(triangles[2]) + self.get_area(triangles[3])):
+ return triangles[0:2]
+ else:
+ return triangles[2:4]
+
+ def get_vector(self, vertice_1, vertice_2):
+ x = vertice_2[0] - vertice_1[0]
+ y = vertice_2[1] - vertice_1[1]
+ z = vertice_2[2] - vertice_1[2]
+
+ return [x, y, z]
+
+ def get_vertice(self, offset, vector, Lambda):
+ x = offset[0] + vector[0] * Lambda
+ y = offset[1] + vector[1] * Lambda
+ z = offset[2] + vector[2] * Lambda
+
+ return [x, y, z]
+
+screen.geometry = geometry()
+
class preview:
def __init__(self, parent):
# show preview image
@@ -23,181 +115,213 @@
# set autoredraw
self.preview.connect('expose_event', self.redraw)
+ # select the right object as the drawing area
+ self.drawing_area = self.preview.window
+
# define the colors
self.preview.window.colors = {}
for color_name, color_content in colors.items():
- self.preview.window.colors[color_name] = self.preview.window.new_gc(foreground = self.preview.window.get_colormap().alloc_color(color_content))
+ self.drawing_area.colors[color_name] = self.drawing_area.new_gc(foreground = self.drawing_area.get_colormap().alloc_color(color_content))
+ # grab the face
+ self.face = model['faces'][window.face_number]
+
+ # create the base line
+ self.base_line = screen.geometry.get_vector(self.face['vertices'][0], self.face['vertices'][1])
+
+ # get the offset
+ self.offset = self.face['vertices'][0]
+
+ # get the angle between the offset and the base line
+ angle = screen.geometry.get_angle(self.base_line, self.offset)
+
+ # get the length of the offset
+ length = screen.geometry.get_distance(self.offset)
+
+ # calculate the x- and y-coordinate of the offset
+ self.offset_x = cos(angle) * length
+ self.offset_y = sin(angle) * length
+
def redraw(self, widget = none, event = none):
# add the drawing to the background processes
background_processes.add('drawing the preview image', self.draw)
def draw(self):
- # select the right object as the drawing area
- drawing_area = self.preview.window
-
# clear the drawing area
- drawing_area.clear()
+ self.drawing_area.clear()
- # grab the face
- face = model['faces'][window.face_number]
+ # create the border
+ self.create_border()
- # create an array for the base line
- base_line = {}
+ # create the triangles
+ self.create_triangles()
- # grab the edge of the base line
- base_line['edge'] = face['edges'][face['base_line']]
+ # insert a dummy texture
+ self.insert_texture()
- # calculate distance between the 2 vertices of the base line
- base_line['length'] = screen.geometry.get_distance(base_line['edge'][0], base_line['edge'][1])
+ def insert_texture(self):
+ for plane in self.planes:
+ # get vector lengths
+ length_1 = screen.geometry.get_distance(plane['vectors'][0])
+ length_2 = screen.geometry.get_distance(plane['vectors'][1])
- # calculate the normal vector of the base line
- base_line['vector'] = screen.geometry.get_vector(base_line['edge'][0], base_line['edge'][1])
+ # calculate end values
+ end_1 = (length_1/0.01) * resolution_texture_map
+ end_2 = (length_2/0.01) * resolution_texture_map
- # create a temporary array for the planes
- planes = []
+ for x_pixel_number in range(0, end_1):
+ # get the relative x coordinate
+ x_relative = x_pixel_number/end_1
- for vertice in face['vertices']:
- # create/reset the array for the plane
- plane = {}
+ for y_pixel_number in range(0, end_2 * (1 - x_relative)):
+ # get the relative y coordinate
+ y_relative = y_pixel_number/end_2
- # create a plane with the normal vector of the base line and the offset of the vertice
- plane['parameters'] = screen.geometry.get_plane(vertice, base_line['vector'])
+ # create/reset the array for the absolute position
+ absolute = []
- # store the vertice in the plane
- plane['vertice'] = vertice
+ # get the absolute position in the room
+ absolute.append(plane['offset'][0] + plane['vectors'][0][0] * x_relative + plane['vectors'][1][0] * y_relative)
+ absolute.append(plane['offset'][1] + plane['vectors'][0][1] * x_relative + plane['vectors'][1][1] * y_relative)
+ absolute.append(plane['offset'][2] + plane['vectors'][0][2] * x_relative + plane['vectors'][1][2] * y_relative)
- # store the plane in the planes array
- planes.append(plane)
+ # get the relative position on the drawing area
+ x, y = self.get_relative_position(absolute)
- for plane in planes:
- # calculate lambda with the plane and the offset of the first vertice of the base line
- plane['lambda'] = screen.geometry.get_lambda(base_line['edge'][0], plane['parameters'])
+ # get the absolute position on the drawing area
+ x, y = self.get_absolute_position(x, y)
- for plane in planes:
- # calculate the point of intersection
- plane['intersection'] = screen.geometry.get_vertice(base_line['edge'][0], base_line['vector'], plane['lambda'])
+ # draw the pixel
+ self.drawing_area.draw_point(self.drawing_area.colors['red'], x, y)
- # create arrays for the coordinates
- x = []
- y = []
+ def create_border(self):
+ # define arrays for the coordinates
+ self.border_x = []
+ self.border_y = []
- # get the coordinates
- for plane in planes:
- # store the x-coordinate
- x.append(plane['lambda'] * base_line['length'])
+ # store the x- and y-coordinate
+ self.border_x.append(self.offset_x)
+ self.border_y.append(self.offset_y)
- # store the y-coordinate
- y.append(screen.geometry.get_distance(plane['vertice'], plane['intersection']))
+ for vertice in self.face['vertices'][1:]:
+ # get the relative position
+ x, y = self.get_relative_position(vertice)
+ # store the x- and y-coordinate
+ self.border_x.append(x)
+ self.border_y.append(y)
+
# calculate lengths
- x_length = max(x) - min(x)
- y_length = max(y) - min(y)
- max_length = max(x_length, y_length)
+ self.x_length = max(self.border_x) - min(self.border_x)
+ self.y_length = max(self.border_y) - min(self.border_y)
+ self.max_length = max(self.x_length, self.y_length)
+ # create a copy of the coordinates
+ temp_x = self.border_x[:]
+ temp_y = self.border_y[:]
+
# scale the x coordinates to become values between -1 and 1
- for i in range(0 , len(x)):
- x[i] /= max_length
+ for i in range(0 , len(temp_x)):
+ temp_x[i] /= self.max_length
# scale the y coordinates to become values between -1 and 1
- for i in range(0 , len(y)):
- y[i] /= max_length
+ for i in range(0 , len(temp_x)):
+ temp_y[i] /= self.max_length
# calculate the center for the x-axis
- x_center = 1
- x_center -= x_length/max_length
- x_center /= 2
- x_center -= min(x)
+ self.x_center = 1
+ self.x_center -= self.x_length/self.max_length
+ self.x_center /= 2
+ self.x_center -= min(temp_x)
# calculate the center for the y-axis
- y_center = 1
- y_center -= y_length/max_length
- y_center /= 2
- y_center -= min(y)
+ self.y_center = 1
+ self.y_center -= self.y_length/self.max_length
+ self.y_center /= 2
+ self.y_center -= min(temp_y)
- # center the x coordinates
- for i in range(0 , len(x)):
- x[i] += x_center
+ # create an array for the points of the polygon
+ points = []
- # center the y coordinates
- for i in range(0 , len(y)):
- y[i] += y_center
+ # position the coordinates
+ for i in range(0, len(self.border_x)):
+ points.append(self.get_absolute_position(self.border_x[i], self.border_y[i]))
- # scale the x coordinates to fit on the drawing area
- for i in range(0 , len(x)):
- x[i] *= view_size * 2
+ # draw the highlighted face
+ self.drawing_area.draw_polygon(self.drawing_area.colors['pink'], false, points)
- # scale the y coordinates to fit on the drawing area
- for i in range(0 , len(y)):
- y[i] *= view_size * 2
+ def create_triangles(self):
+ # get the triangles
+ try:
+ model['faces'][window.face_number]['triangles']
+ except:
+ model['faces'][window.face_number]['triangles'] = screen.geometry.get_triangles(self.face['vertices'])
- # round the x coordinates
- for i in range(0 , len(x)):
- x[i] = int(round(x[i]))
+ triangles = model['faces'][window.face_number]['triangles']
- # round the y coordinates
- for i in range(0 , len(y)):
- y[i] = int(round(y[i]))
+ # create an array for the planes of the triangles
+ self.planes = []
- # create an array for the points of the polygon
- points = []
+ # define planes for the triangles
+ for triangle in triangles:
+ # get the offset
+ offset = triangle[0]
- # insert the coordinates to the points array
- for i in range(0 , len(x)):
- points.append((x[i], y[i]))
+ # calculate the vectors
+ vector_1 = screen.geometry.get_vector(offset, triangle[1])
+ vector_2 = screen.geometry.get_vector(offset, triangle[2])
- # draw the highlighted face
- drawing_area.draw_polygon(drawing_area.colors['pink'], false, points)
+ # get the plane
+ plane = screen.geometry.get_plane(offset, vector_1, vector_2)
- def rotate(self, widget, direction):
- model['faces'][window.face_number]['base_line'] += 1 * direction
+ # store the plane
+ self.planes.append(plane)
- if model['faces'][window.face_number]['base_line']<0:
- model['faces'][window.face_number]['base_line'] = len(model['faces'][window.face_number]['edges']) - 1
- elif model['faces'][window.face_number]['base_line']>(len(model['faces'][window.face_number]['edges']) - 1):
- model['faces'][window.face_number]['base_line'] = 0
+ def get_relative_position(self, vertice):
+ # get the vector
+ vector = screen.geometry.get_vector(self.offset, vertice)
- # redraw the face
- self.redraw()
+ # get the angle of the vector
+ angle = screen.geometry.get_angle(self.base_line, vector)
- def exit_screen(self, widget):
- show_screen('project/canvas')
+ # get the length of the vector
+ length = screen.geometry.get_distance(vector)
-screen.preview = preview(table)
+ # calculate the x- and y-coordinate of the vector
+ vector_x = cos(angle) * length
+ vector_y = sin(angle) * length
-class geometry:
- def get_distance(self, vertice_1, vertice_2):
- return sqrt((vertice_1[0] - vertice_2[0]) ** 2 + (vertice_1[1] - vertice_2[1]) ** 2 + (vertice_1[2] - vertice_2[2]) ** 2)
+ # add the x and y-coordinate of the offset
+ vector_x += self.offset_x
+ vector_y += self.offset_y
- def get_vector(self, vertice_1, vertice_2):
- x = vertice_2[0] - vertice_1[0]
- y = vertice_2[1] - vertice_1[1]
- z = vertice_2[2] - vertice_1[2]
+ return (vector_x, vector_y)
- return [x, y, z]
+ def get_absolute_position(self, x, y):
+ # scale the coordinates to become values between -1 and 1
+ x /= self.max_length
+ y /= self.max_length
- def get_plane(self, vertice, vector):
- a = vector[0]
- b = vector[1]
- c = vector[2]
+ # center the coordinates
+ x += self.x_center
+ y += self.y_center
- d = (vertice[0] * vector[0]) + (vertice[1] * vector[1]) + (vertice[2] * vector[2])
+ # scale the coordinates to fit on the drawing area
+ x *= (view_size * 2) - 1
+ y *= (view_size * 2) - 1
- return [a, b, c, d]
+ # round the coordinates
+ x = int(round(x))
+ y = int(round(y))
- def get_lambda(self, vertice, plane):
- return ((plane[3] - plane[0]*vertice[0] - plane[1]*vertice[1] - plane[2]*vertice[2])/(plane[0]**2 + plane[1]**2 + plane[2]**2))
+ return (x, y)
- def get_vertice(self, offset, vector, Lambda):
- x = offset[0] + vector[0] * Lambda
- y = offset[1] + vector[1] * Lambda
- z = offset[2] + vector[2] * Lambda
+ def exit_screen(self, widget):
+ show_screen('project/canvas')
- return [x, y, z]
+screen.preview = preview(table)
-screen.geometry = geometry()
-
class tools:
def __init__(self, parent):
# create an empty toolbar
@@ -205,20 +329,6 @@
parent.attach(self.bar, 0, 1, 0, 1)
self.bar.show()
- # create the "rotate counterclockwise" icon
- image = gtk.Image()
- image.set_from_file(path[0] + '/graphic/buttons/edit_the_face/rotate_counterclockwise.png')
-
- # add the "rotate counterclockwise" button
- self.bar.append_item('rotate', 'rotate the model counterclockwise', none, image, screen.preview.rotate, 1)
-
- # create the "rotate clockwise" icon
- image = gtk.Image()
- image.set_from_file(path[0] + '/graphic/buttons/edit_the_face/rotate_clockwise.png')
-
- # add the "rotate clockwise" button
- self.bar.append_item('rotate', 'rotate the model clockwise', none, image, screen.preview.rotate, -1)
-
# create the "exit screen" icon
image = gtk.Image()
image.set_from_file(path[0] + '/graphic/buttons/edit_the_face/exit_screen.png')
Modified: branches/ogEditor/data/modules/texturizer/scripts/screens/project/new/frames/start_a_new_project.py
===================================================================
--- branches/ogEditor/data/modules/texturizer/scripts/screens/project/new/frames/start_a_new_project.py 2009-03-01 16:02:46 UTC (rev 1081)
+++ branches/ogEditor/data/modules/texturizer/scripts/screens/project/new/frames/start_a_new_project.py 2009-03-01 16:51:03 UTC (rev 1082)
@@ -133,7 +133,7 @@
edges = self.save_edges(face_new)
# save the new face in the model['faces'] array
- model['faces'].append({'vertices' : face_new, 'edges' : edges, 'base_line' : 0})
+ model['faces'].append({'vertices' : face_new, 'edges' : edges})
# update length values
model['dimensions'][0]['length'] = model['dimensions'][0]['max'] - model['dimensions'][0]['min']
Deleted: templates/branches/ogEditor/data/modules/texturizer/graphic/buttons/edit_the_face/rotate.pspimage
===================================================================
(Binary files differ)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
