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)