kevin4998 / mr-shape-database Goto Github PK

Get all the shapes from the Princeton and Labeled PSB Dataset into the project.

Processing the entire Princeton or PSB databases can be very challenging! These contain hundreds of shapes in multiple classes. A good way to proceed with the assignment is to first consider a reduced database. The key constraints here are that:

• The reduced database should contain at least 200 shapes;
• You should have shapes of most (ideally all) of the 19 class types;
• Try to balance the classes, i.e., do not use tens of models of one class and only a handful of models of another class.

Given a query shape, modify the simple query mechanism built in Step 4 to return the K-nearest neighbors or the R-nearest neighbors (where K and R are user-supplied parameters), using ANN.

Get 4 3D shapes from the Princeston Shape Benchmarks and Labeled PSB Dataset

• 2 PLY Shapes
• 2 OFF Shapes

Setting required for the evaluation. The K-value will now automatically always be equal to class size.

Display a read-in shape with shading using OpenGL. Drawing Cell-Edges is optional but advised. If you do this make sure that you can turn it on or off by keystrokes.

Requires #4

Create a method to calculate each of the following properties of objects:

• Compactness (with respect to a sphere)
• Axis-Aligned Bounding-Box volume
• Diameter
• Eccentricity (Ratio between largest and smallest eigenvalues of covariance matrix)

When using the internal shapedatabase, it would be useful to also load in their feature vectors rather than recalculating it.

Create a function to compute the surface area of a 3D shape using the algorithms mentioned during the lecture.

Refine the outliers so that it can be used for real feature extraction later on. (splitting larger faces into smaller ones and visa versa).

These meshes can be refined with different tools such as GeomView or OFF mesh tools package.

Have the program be able to:

• Rotate Shapes (around viewpoint)
• Zoom in/out
• Pan/Translate Shapes

Requires #6

Read in PLY or OFF shapes from a file into a datastructure. Only 1 structure needs to be read. Check out which one is the easiest to work with, not the easiest to convert.

Allow for values which will easily change, like the weights and number of returned results, to be able to be read and changed from ini files.

• Ini file outline: Which variables to implement and how.
• Ini file reading in custom object
• Ini object conversion to Settings

Calculate the Epsilon of the extendmesh java iteration based upon the bounding box and max number of vertices.

A vertice should get a chance of being picked, proportionally to the size(s) of its surrounding triangles.

Extract 4 basic features from the databases:

• The class of the shape (specified in file)
• The number of faces and vertices
• The type of faces (triangles, quads, mix)
• The axis-aligned 3D bounding box

Test all the previous requirement to make sure tthat we can move on.

• #5 Converting Shapes from one format to the other
• #4 Reading Shapes into a datastructure
• #6 Visualising Shapes onto the screen
• #7 Inspecting Shapes in a variation of ways

Currently, the query meshes only get class 'query'. They should be placed in folders with their class.

The current writer works incorrectly on some systems and writes out decimal values with a ',' rather than '.' making our java systems and our own unable to read the files back in. Furthermore multiple exceptions occure within those java environments because of this process. So somewhere something goes wrong, find it and eliminate it.

• Discover source of the ','/'.' issue
• Rewrite writer to be able to only output points
• Discover source of errors for the java processes
• Make a fail-safe and fix/prevent it from happening.

Compare 2 normalised elementary descriptors with each other.

Change the histograms to cumulative histograms

A local of local descriptors need to be calculated later on. However it is not easy to compare local descriptors between shape. It make this process easier, a class should be made which contains a histogram of all the local descriptors (of one type) and is able to compare a histogram of the same type between two shapes.

• Create generic histogram which can contain values of local descriptors
• Normalise histogram values so amount of samples does not matter.
• Allow comparison of the same descriptor types in the class

Allow visual studio to start a basic Console Application showing that this project works.

Currently, a new ANN structure is created for each query. This can be created once out of the whole database and reused.

Add all the basic files requested by github to define your project:

• README.md: Explaining the repository and assignment requirements.
  • Description
  • Getting Started: Prerequisites, Installing
  • Deployment
  • Built With
  • Contributions
  • Authors
  • License
  • Acknowledgements
• LICENSE.md: Give it a license to call this project our own.
• CODEOWNERS: The participants and responsible owners of the repository.

Design a simple normalization tool, the tool should read each shape, translate it so that its barycenter coincides with the coordinate-frame origin, and scale it uniformly so that it tightly fits in a unit-sized cube centered in the origin.

• Scale up or down to the [-1,1] region
• Move to the barycenter point

Convert PLY to OFF or OFF to PLY formats to have 1 consistent collection of shapes.

Create an instance of the histogram class which can calculate the follow for each shape:

• Distance between the barycenter and a random vertex
• Distance between 2 random vertices
• Square root of an area of a triangle given by 3 random vertices
• Cube root of volume of tetrahedron formed by 4 random vertices

A (large) number of random points should be used for these properties, the exact amount should be figured out through testing, so make sure we can modify a property to determine the random amount. It is best to place this value in the Settings.

Use the variaty of methods which we made to calculate descriptors for all the shapes and store these in a seperate file for quick reloading so we don't need recalculate them all.

• Be able to calculate descriptors
• Make the generation automatic
• Save the data to a seperate file
• Load in all descriptors for shapes

Implement all quality metric. Motivate your choice and describe how you implement the respective metric based on how the query system works (you provide a query shape and number K, you get K shapes in return).

Metrics

• Accuracy: (Correct Relevant + False Irrelevant) / Total
• Precision: Correct Relevant / All Correct
• Recall: Correct Relevant / All Relevant
• Specificity: Incorrect Irrelevant / All Irrelevant
• Sensitivity: Correct Relevant / All Irrelevant

The current CSV exporter only exports in either ',' or ';'. This should not be hardcoded and should be determined from the culture.

Use the histogram class to create an instance which contains the angle between 3 random vertices in the shape.

A (large) number of random points should be used for these properties, the exact amount should be figured out through testing, so make sure we can modify a property to determine the random amount. It is best to place this value in the Settings.

Rework the normalisation processing to be a refinement operation which will:

• Center the figure at its barycenter
• Align the shape via the eigenvectors (Use PCA)
• Scale the shape to fit a [-1,1] range
• Flip the shape with the momentum test along 3 axis.

The previous java file does not simplify shapes but only combine points. We need to write either our own program or find one online which reduces the amount of vertices for our shape.

In the FeatureManager which contains all the featurevectors should these 2 methods be added and the data needs to be saved in DescriptionProperties (The ini manager).

• Calculate Average for all vectors
• Calculate Standard deviation for all vectors
• Normalise all featurevectors (in particular the elementary descriptors)
  • Give decision to calculate new or get them from ini file.

Currently the Controller makes use of a single Options object with all the variables which can be changed, however this should be improved with special modes called: "Verbs". The Console Line Reader package has explanations about Verbs and how we can best implement it.

• Requirement: Issue concerning caching needs to be solved.
• New UI directory for all the console classes.
• Verb for viewing files
• Verb for Refining files
• Verb for Measuring/Analysing shapes
• Verb for Feature Extraction
• Verb for Querying
• Verb for Evaluation/Analysing results
• Ensure multiple verbs can be called at the same time.

Export all the different features from the shapes into a seperate file such as an excel sheet. On this sheet find the:

• Average shape in the database (in terms of size and cell types)
• The significant outliers from the averages (very large or very small sizes)
• Visualise these outliers and note them down

Write a batch file to change all names.

Take the feature database (all feature vectors computed for all shapes in the database, already constructed in Step 3) and construct a spatial search structure for it. For this, use the Approximate Nearest Neighbor (ANN) library (see Pointers on Website).

Define some statistics for the shapes and extract these during the different design phases:

• Original shapes
• Outlier normalisation
• Full normalisation

The Princeton Shape Library makes us of specific .cla files to determine the classification. We need to convert this classification to our map structure where each map is a class.

Write in Google Drive the final report with 25 pages.

• General layout of report
• Task Division
• Writing Each Chapter

Currently the application sometimes load cache values and othertimes not. It should be improved so that it can be specified if cached data should be loaded or recalculated. Our default usage should be loading previous data.

• Load cache variable
• Every file should be behind this if statement
• Correct Reading and Writing of cache data