def createSummaries(fileHandler, dataset):
result = []
for i in range(ModelType._COUNT):
result.append([])
files = fileHandler.findAll()
refObj = fileHandler.load(files[0])
for i in range(1, len(files)):
obj = fileHandler.load(files[i])
colorDiffs = colordiff.compare(refObj.renderResult.colors, obj.renderResult.colors)
summary = Summary(obj, colorDiffs)
result[obj.modelType].append(summary)
return result
def plotPixels(self, rhoNo=1, phiNo=1, tfNo=1):
dataset = Dataset(rhoNo, phiNo, tfNo)
pixelFigure = PixelFigure(self.texDimSizes)
directPixels = []
voxelPixels = []
baPixels = []
hybridPixels = []
hybridVoxelRatios = []
baHybridPixels = []
baHybridVoxelRatios = []
filedir = self.filedir(dataset)
self.fileHandler.setFiledir(filedir)
files = self.fileHandler.findAll()
refObj = self.fileHandler.load(files[0])
refPixels = refObj.renderResult.colors
pixelFigure.refPixelsPlot.plotPixelColors(refPixels)
for i in range(1, len(files)):
obj = self.fileHandler.load(files[i])
objPixels = obj.renderResult.colors
if obj.modelType == ModelType.DIRECT:
directPixels.append(objPixels)
elif obj.modelType == ModelType.VOXEL:
voxelPixels.append(objPixels)
elif obj.modelType == ModelType.BOUNDARYACCURATE:
baPixels.append(objPixels)
elif obj.modelType == ModelType.HYBRID:
hybridPixels.append(objPixels)
hybridVoxelRatios.append(obj.renderResult.ratios)
elif obj.modelType == ModelType.BAHYBRID:
baHybridPixels.append(objPixels)
baHybridVoxelRatios.append(obj.renderResult.ratios)
if len(directPixels) == 1:
pixels = directPixels[0]
colorDiffs = colordiff.compare(refPixels, pixels)
pixelFigure.directPixelsPlot.plotPixelColors(pixels)
pixelFigure.directDiffsPlot.plotPixelColorDiffs(colorDiffs)
for i in range(len(voxelPixels)):
pixels = voxelPixels[i]
colorDiffs = colordiff.compare(refPixels, pixels)
pixelFigure.voxelPixelsPlots[i].plotPixelColors(pixels)
pixelFigure.voxelDiffsPlots[i].plotPixelColorDiffs(colorDiffs)
pixels = baPixels[i]
colorDiffs = colordiff.compare(refPixels, pixels)
pixelFigure.baPixelsPlots[i].plotPixelColors(pixels)
pixelFigure.baDiffsPlots[i].plotPixelColorDiffs(colorDiffs)
pixels = hybridPixels[i]
colorDiffs = colordiff.compare(refPixels, pixels)
pixelFigure.hybridPixelsPlots[i].plotPixelColors(pixels)
pixelFigure.hybridDiffsPlots[i].plotPixelColorDiffs(colorDiffs)
pixelFigure.hybridVoxelRatioPlots[i].plotRatios(hybridVoxelRatios[i])
pixelFigure.show()
def run(self, rhoNo=1, phiNo=0, tfNo=1):
dataset = Dataset(rhoNo, phiNo, tfNo)
texDimSize = 128
renderer = Renderer(self.eye, self.screen)
rho = dataset.rho
phi = dataset.phi
tf = dataset.tf
phiPlane = SplinePlane(phi, self.splineInterval, self.intersectTolerance)
boundingBox = phiPlane.createBoundingBox()
plotter = Plotter(self.splineInterval)
refSplinePlotter = plotter.refSplineModelPlotter
directSplinePlotter = plotter.directSplineModelPlotter
voxelPlotter = plotter.voxelModelPlotter
paramPlotter = plotter.paramPlotter
refSplinePlotter.plotGrid(phi.evaluate, 10, 10)
directSplinePlotter.plotGrid(phi.evaluate, 10, 10)
paramPlotter.plotGrid(10, 10)
paramPlotter.plotScalarField(rho, tf)
refSplinePlotter.plotBoundingBox(boundingBox)
directSplinePlotter.plotBoundingBox(boundingBox)
voxelPlotter.plotBoundingBox(boundingBox)
# Creating models
refSplineModel = SplineModel(tf, phiPlane, rho, self.refTolerance)
directSplineModel = SplineModel(tf, phiPlane, rho)
samplingScalars = refSplineModel.generateScalarMatrix(boundingBox, texDimSize, texDimSize,
self.voxelizationTolerance)
#voxelPlotter.plotScalars(samplingScalars, boundingBox)
scalarTexture = Texture2D(samplingScalars)
plotter.plotScalarTexture(scalarTexture)
voxelModel = VoxelModel(tf, scalarTexture, boundingBox)
choice = 0
if choice == 0:
model = voxelModel
modelType = ModelType.VOXEL
elif choice == 1:
model = BoundaryAccurateModel(tf, directSplineModel, voxelModel)
modelType = ModelType.BOUNDARYACCURATE
elif choice == 2:
voxelWidth = boundingBox.getHeight() / float(texDimSize)
criterion = GeometricCriterion(self.screen.pixelWidth, voxelWidth)
model = HybridModel(tf, directSplineModel, voxelModel, criterion)
modelType = ModelType.HYBRID
else:
lodTextures = [scalarTexture]
size = texDimSize / 2
while size >= 2:
scalars = refSplineModel.generateScalarMatrix(boundingBox, size, size, self.voxelizationTolerance)
lodTextures.append(Texture2D(scalars))
size /= 2
model = VoxelLodModel(tf, lodTextures, boundingBox, self.screen.pixelWidth)
modelType = ModelType.VOXEL
# Rendering
refRenderData = RenderData(ModelType.REFERENCE, self.viewRayDeltaRef)
refRenderData.renderResult = renderer.render(refSplineModel, self.viewRayDeltaRef, refSplinePlotter)
directRenderData = RenderData(ModelType.DIRECT, self.viewRayDelta)
directRenderData.renderResult = renderer.render(directSplineModel, self.viewRayDelta, directSplinePlotter)
renderData = RenderData(modelType, self.viewRayDelta, texSize=texDimSize)
renderData.renderResult = renderer.render(model, self.viewRayDelta, voxelPlotter)
# Plotting
refPixelColors = refRenderData.renderResult.colors
directPixelColors = directRenderData.renderResult.colors
pixelColors = renderData.renderResult.colors
plotter.pixelReferencePlot.plotPixelColors(refPixelColors)
plotter.pixelDirectPlot.plotPixelColors(directPixelColors)
plotter.pixelVoxelizedPlot.plotPixelColors(pixelColors)
directDiffs = colordiff.compare(refPixelColors, directPixelColors)
diffs = colordiff.compare(refPixelColors, pixelColors)
plotter.pixelDirectDiffPlot.plotPixelColorDiffs(directDiffs)
plotter.pixelVoxelizedDiffPlot.plotPixelColorDiffs(diffs)
plotter.draw()
# Printing
directSummary = Summary(directRenderData, directDiffs)
directSummary.printData()
print ""
summary = Summary(renderData, diffs)
summary.printData()
if modelChoice == 3 or modelChoice == 4:
renderer = HybridRenderer(eye, screen)
renderResult = renderer.render(model, viewRayDelta)
ratios = renderResult.ratios
else:
renderer = Renderer(eye, screen)
renderResult = renderer.render(model, viewRayDelta)
colors = renderResult.colors
fileHandler = FileHandler()
fileHandler.setFiledir('output/vgresults')
refObj = fileHandler.load('reference.pkl')
refColors = refObj.renderResult.colors
colorDiffs = colordiff.compare(refColors, colors)
p = PixelPlotter(ax)
p.plotPixelColors(colors)
ax.set_aspect(aspectRatio)
pdiff = PixelPlotter(axdiff)
pdiff.plotPixelColorDiffs(colorDiffs)
axdiff.set_aspect(aspectRatio)
fig.tight_layout()
figdiff.tight_layout()
plt.figure(fig.number)
plt.savefig("output/vg/pixels{}.pdf".format(name), format="pdf", transparent=True)
