import re, io, os

import numpy as np

import vtk

from vtk import *

from sklearn.neighbors import KDTree

from functools import reduce

import winsound

import scipy.stats as stats

import pylab as pl

import math

import matplotlib.pyplot as plt

import mplstereonet

import random

import time

import skfuzzy as fuzz

import DetMM as dm

import qn

##########################################################################################################################

# Input parameters

file_to_read="model-Copy.obj"

k=10 # Number of neighbors for each point

max_curv=0.4 # Not used

min_dot=0.97 # Not used

min_plane=20 # The mininum number of points making up a plane

##########################################################################################################################

# This class is intended to setup and show VTK interactive windows

class VtkPointCloud:

self.vtkPolyData.GetPointData().SetActiveScalars('DepthArray')

###########################################################################################

# This function performs PCA to find out which points are feature-points

def PreCoplaner(total, indices, k):

return normals, curvatures

# This method estimates the normal vector to each point using the Robust estimation

def coplaner(total, indices, k, normals, mod_curv):

return normals

# In order to illustrate points, this method classifies point value into steps

def classifier(Colors):

return Colors

# The following function converts the coefficients of normal vectors to dips and dip angles

def spherical_coor(normals):

return angles

# The function below attempts to illustrate the input values in the StereoNets

def plotter(data):

plt.show()

# The following methods calculated the normalized dot product of the inputs

def normal_mean(normal):

return valN

################################################################

# The proceeding function recieves bandles of planes in form of arrays. By iterating through planes, it assign colors based on the clustering outputs.

# Then, the points making up planes go through Delaunay procedure to be representable on the screen on VTK wind.

def Delaunay(grand_nei, total, cluster_membership):

print(itera)

##############################################################################################

#The following function depicts normal vectors.

def normal_drawer(plane_normal, plane_seed):

renderer.AddActor(actor)

####################################################################################################

# Here the region growing algorithm is implemented

def region_growing2(normals, indices, curvature, total, oriCurv, k):

return plane_normal0, plane_seed, grand_nei

#########################################################################################################################################

if file_to_read.endswith('.dae'):

print("openning dae file")

import collada_importer as ci

total=ci.collada_importer0(file_to_read)

elif file_to_read.endswith('.obj'):

print("opening obj file")

import obj_importer as ob

total=ob.obj_importer0(file_to_read)

else:

print("not supported format")

exit()

pointCloud = VtkPointCloud()

print(" Finding neighbors...")

# Using kd tree to find neighbors to each point

tree=KDTree(total)

distances, indices =tree.query(total, k)

total=total[np.where(distances[:,1] != 0)]

tree=KDTree(total)

distances, indices =tree.query(total, k)

# Defining a Renderer

renderer = vtk.vtkRenderer()

renderer.AddActor(pointCloud.vtkActor)

renderer.SetBackground(1, 1, 1)

renderer.ResetCamera()

#renderer.SetActiveCamera(camera);

num_to_show=len(indices)

print(" Finding points normal...")

inp=input("Shall I upload the normal vectors from previous sessions? (If this is your first time running the program, press n )(y/n) ")

if (inp=='n'):

print('It might take couple of hours. So be paitient')

normals, precurv= PreCoplaner(total, indices[:num_to_show], 5)

Cmin=min(precurv)

Cmax=max(precurv)

precurv=(precurv-Cmin)/(Cmax-Cmin)

mod_curv=classifier(precurv)

print("Done the first part, now performing Robust normal estimation")

normals = coplaner(total, indices[:num_to_show], 5, normals, mod_curv)

np.savetxt('normal.out', normals, delimiter=',')

np.savetxt('curvatures.out', mod_curv, delimiter=',')

exit()

elif (inp=='y'):

print("The data will be uploaded from previous sessions")

normals=np.loadtxt("normal.out", delimiter=',')

curvatures=np.loadtxt("curvatures.out", delimiter=',')

else:

print(" AS you did not enter the correct keywords (y or n), the program stops")

exit()

print(" Calculating coplannarity...")

#mod_curv=classifier(25*curvatures)

mod_curv=curvatures

inp=input("Do you want to do the region growing? (If this is the first time you are running the code, press y ) (y/n) ")

if (inp=='y'):

import RG

RG.main()

"""

plane_normal, plane_seed, grand_nei=region_growing2(normals, indices, mod_curv, total, curvatures, k)

np.savetxt('Pnormal3.out', plane_normal, delimiter=',')

#np.savetxt('Gnei.out', grand_nei, delimiter=',')

try:

os.unlink('Gnei3.txt')

except:

print("could not delete")

try:

os.unlink('Pseed3.txt')

except:

print()

try:

np.savetxt('Gnei3.out', grand_nei, delimiter=',')

except:

with open('Gnei3.txt', 'w') as f:

for item in grand_nei:

f.write("%s\n" % item)

with open('Pseed3.txt', 'w') as f:

for item in plane_seed:

f.write("%s\n" % item)

print(" With all the components constructed, you now need to run the program again skipping the first two parts to proceed to the following sections")

exit()

"""

elif(inp=='n'):

plane_normal=np.loadtxt("Pnormal3.out", delimiter=',')

#plane_seed=np.loadtxt("Pseed.txt", delimiter=',')

file = open("Pseed3.txt", "r")

plane_seed=file.readlines()

file = open("Gnei3.txt", "r")

gt=file.read()

grand_nei=[]

for i in range(len(plane_seed)):

loc1=gt.find("[")

gt=gt[loc1 :]

loc2=gt.find("]")

row=gt[loc1+1:loc2]

gt=gt[(loc2+2) :]

grand_nei.append(row)

print(i)

else:

print(" AS you did not enter the correct keywords (y or n), the program stops")

exit()

plane_normal_deg=spherical_coor(plane_normal)

# normalizing the normals

for i in range(len(plane_normal)):

dist=math.sqrt(plane_normal[i,0]**2+plane_normal[i,1]**2+plane_normal[i,2]**2)

plane_normal[i,0]=abs(plane_normal[i,0])/dist

plane_normal[i,1]=abs(plane_normal[i,1])/dist

plane_normal[i,2]=abs(plane_normal[i,2])/dist

# plane classification using Fuzzy clustering

cntr, u, u0, d, jm, p, fpc = fuzz.cluster.cmeans(

plane_normal.T, 3, 2, error=0.005, maxiter=1000, init=None)

cluster_membership = np.argmax(u, axis=0)

#Doing Delaunay

Delaunay(grand_nei, total, cluster_membership)

#Drawing normals

normal_drawer(0.05*plane_normal, plane_seed)

#Plotting on Stereonets

plotter(plane_normal_deg)

# Presenting the distribution of curvatures on a Histogram

plt.hist(curvatures, color = 'blue', edgecolor = 'black',

bins = int(500))

plt.axis([0,0.125,0,45000])

plt.show()

# If needed, comment out the following code snippet to represent the points in the output

"""

for i in range(num_to_show):

#pointCloud.addPoint([total[i,0],total[i,1],total[i,2]], 10000*curvatures[i])

pointCloud.addPoint([total[i,0],total[i,1],total[i,2]], 255)

"""

# Setting up vectors

transform = vtk.vtkTransform()

transform.Translate(1.0, 0.0, 0.0)

axes = vtk.vtkAxesActor()

# The axes are positioned with a user transform

axes.SetUserTransform(transform)

renderer.AddActor(axes)

# Render Window

renderWindow = vtk.vtkRenderWindow()

renderWindow.AddRenderer(renderer)

# Interactor

renderWindowInteractor = vtk.vtkRenderWindowInteractor()

renderWindowInteractor.SetRenderWindow(renderWindow)

renderWindowInteractor.Initialize()

# Begin Interaction

renderWindow.Render()

renderWindowInteractor.Start()