#!/usr/bin/python

# -*- coding: utf-8 -*-

from math import sin, radians, degrees, atan2, copysign, sqrt

from colorsys import hsv_to_rgb

from itertools import izip, combinations

from tempfile import TemporaryFile as temp

import numpy as np

from networkx import Graph, connected_components

from IPython import embed

def calc_sphere(x, y, z):

"""Calculate spherical coordinates for axial data."""

return np.degrees(np.arctan2(*(np.array((x,y))*np.sign(z)))) % 360, np.degrees(np.arccos(np.abs(z)))

def general_axis(data, order=0):

return cone_axis/np.linalg.norm(cone_axis)

def calibrate_azimuth(data, target_color, target_azimuth):

return data

# def load_ply(f):

# f = open(fname, "rb")

# line = ""

# while "end_header" not in line:

# line = f.readline()

# if line.startswith("element vertex"): vertex_n = int(line.split()[-1])

# if line.startswith("element face"): face_n = int(line.split()[-1])

# data = np.fromfile(f, dtype=[("position", np.float32, 3),("normal", np.float32, 3),("color", np.uint8, 4),],count=vertex_n)

# faces = np.fromfile(f, dtype=[("face_n", np.uint8, 1), ("indices", np.int32, 3),], count=face_n)

# return data, faces

def load_ply(f):

return vertices, faces

def extract_colored_faces(fname, colors):

return output

def extract_colored_point_clouds(fname, colors):

return output

def parse_ply(f, colors, eig=False):

return output

def parse_ply_nx(f, colors, eig=False, network=False):

return output

def color_encode_ply(f, f_out, value=0.7):

r, g, b, alpha))) + "\n")

if __name__ == "__main__":

from datetime import datetime

starttime = datetime.now()

from sys import argv

from optparse import OptionParser, OptionGroup

parser = OptionParser(usage="%prog -f input_filename [options] [color1 color2 ... colorN] [-o output_filename]", version="%prog 0.6")

parser.add_option("-f", "--file", dest="infile", metavar="FILE", help="input painted 3d model")

parser.add_option("-o", "--outfile", dest="outfile", metavar="FILE", help="output color coded 3d model, for use with --colorencode")

parser.add_option("-c", "--colorencode", action="store_true", dest="colorencode", help="Process the model and paints it according to the attitude of each face, based on Assali 2013.", default=False)

parser.add_option("-j", "--join", action="store_true", dest="join", default=False, help="joins all resultant data in a single file, instead of a file for each color as default. Recomended if using --eigen option.")

parser.add_option("-n", "--network", action="store_true", dest="network", help="Outputs each different colored plane, through graph analysis.", default=False)

parser.add_option("-p", "--pointcloud", action="store_true", dest="pointcloud", help="output the plane parameters of the point cloud of each color.", default=False)

# parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help="outputs detailed information on the data", default=False)

group = OptionGroup(parser, "Calibration Options", "These are small utilities to aid calibration of your data.")

group.add_option("-e", "--eigen", action="store_true", dest="eig", help="outputs only the third eigenvector of each color points.", default=False)

group.add_option("-a", "--azimuth", action="store", dest="calibration_data", metavar="COLOR:AZIMUTH", default=None, help="calibrates your output data by turning its azimuth horizontaly until the given color has the given dipdirection")

group.add_option("-u", "--value", action="store", dest="value", help="Determines the value used for the color encode option. Defaults to 0.90.", default=.9)

parser.add_option_group(group)

(options, args) = parser.parse_args()

colors = []

if not options.colorencode:

for color in args:

components = tuple(color.split(','))

if len(components) < 4: components += ('255',)

colors.append(tuple([int(component) for component in components]))

filename = options.infile.split()[0]

with open(options.infile, 'rb') as f:

if options.pointcloud: output = extract_colored_point_clouds(f, colors)

else: output = extract_colored_faces(f, colors)#, options.eig, options.network)

if options.calibration_data:

color, az = options.calibration_data.split(":")

components = tuple(color.split(','))

if len(components) < 4: components += ('255',)

color = components

az = int(az)

# embed()

output = calibrate_azimuth(output, color, az)

#print output

if not options.join:

for color in output.keys():

with open("{0}_{1}.txt".format(filename, color), 'w') as f, open("{0}_{1}_coords.txt".format(filename, color), 'w') as coordf:

coordf.write("X\tY\tZ\tatti\ttrace\n")

for dipdir, dip, X, Y, Z, trace in output[color]:

f.write("{0}\t{1}\n".format(dipdir, dip))

coordf.write("{0}\t{1}\t{2}\t{3}/{4}\t{5}\n".format(X, Y, Z, int(dipdir), int(dip), trace))

#np.savetxt(f, output[color], delimiter="\t",header="dipdir\tdip\tX\tY\tZ")

else:

with open("{0}_attitudes.txt".format(filename), 'w') as f:

for color in output.keys():

f.write("#{0}\n".format(color))

for dipdir, dip in output[color]:

f.write("{0}\t{1}\n".format(dipdir, dip))

else:

with open(options.infile, 'r') as f, open(options.outfile, 'wb') as fo:

color_encode_ply(f, fo, value=float(options.value))

print "Total time processing ", datetime.now() - starttime,"..."

print "\a"