public Texture2D CircuitToTexture()
{
Texture2D outPutTexture;
//generating the quantum circuits encoding the color channels of the image
QuantumCircuit red;
//QuantumCircuit green;
//QuantumCircuit blue;
double[,] imageData = QuantumImageHelper.GetHeightArrayDouble(startTexture, ColorChannel.R);
if (UseSimpleEncoding)
{
red = QuantumImageHelper.ImageToCircuit(imageData);
}
else
{
red = QuantumImageHelper.HeightToCircuit(imageData);
}
Circuit = red;
red.Gates = Gates;
//blue.Gates = Gates;
//green.Gates = Gates;
double[,] redData;//, greenData, blueData;
if (UseSimpleEncoding)
{
redData = QuantumImageHelper.CircuitToImage(red, size, size, RenormalizeImage);
//greenData = QuantumImageHelper.CircuitToImage(green, size, size);
//blueData = QuantumImageHelper.CircuitToImage(blue, size, size);
}
else
{
redData = QuantumImageHelper.CircuitToHeight2D(red, size, size, RenormalizeImage);
//greenData = QuantumImageHelper.CircuitToHeight2D(green, size, size);
//blueData = QuantumImageHelper.CircuitToHeight2D(blue, size, size);
}
//outPutTexture = QuantumImageHelper.CalculateColorTexture(redData, greenData, blueData);
outPutTexture = QuantumImageHelper.CalculateColorTexture(redData, redData, redData, PaintColor.r, PaintColor.g, PaintColor.b);
outPutTexture.filterMode = FilterMode.Point;
outPutTexture.wrapMode = TextureWrapMode.Clamp;
QiskitString = red.GetQiskitString(true);
return(outPutTexture);
}
IEnumerator meshAnimationOptimized()
{
//It is important to create a copy of the vertices and only use "inputMesh.vertices" only once
// since this is a get function. Meaning in every call of the function the mesh will be copied.
Vector3[] inputVertices = InputMesh.vertices;
int numberOfVertices = inputVertices.Length;
//We look at our input being 2 dimensional. One dimension is the number of vertices,
//the other dimension is the vector x,y,z
//We create lines for the first dimension the number of vertices
int numberOfVertexCubits = Mathf.CeilToInt(Mathf.Log(numberOfVertices) / Mathf.Log(2));
//The lines are needed to encode the data in a way that encoding of neighbouring vertices only differ in 1 bit
int[] linesVertices = QuantumImageHelper.MakeLinesInt(numberOfVertexCubits);
//We create lines for the second dimension the vector x,y,z so there are only 3 values (thats where the 3 comes from).
//The 2 is to transform the thing to base 2 since we need the logarithm in base 2.
int numberOfVectorQubits = Mathf.CeilToInt(Mathf.Log(3) / Mathf.Log(2));
//The lines are needed to encode the data in a way that the encoding of x and y as well as y and z only differ in 1 bit.
int[] linesVector = QuantumImageHelper.MakeLinesInt(numberOfVectorQubits);
//Creating a circuit big enough to fit in the mesh data
int numberOfQubits = numberOfVertexCubits + numberOfVectorQubits;
QuantumCircuit circuit = new QuantumCircuit(numberOfQubits, numberOfQubits, true);
//Since we work with probabilities, we need the values to be positive (or 0).
//Therefore we want to translate the values adding an offset to our values, such that they become positive.
//Getting the smallest (most negative) values to use for the displacement
//initiate values as 0
float minX = 0;
float minY = 0;
float minZ = 0;
for (int i = 0; i < inputVertices.Length; i++)
{
if (inputVertices[i].x < minX)
{
minX = inputVertices[i].x;
}
if (inputVertices[i].y < minY)
{
minY = inputVertices[i].y;
}
if (inputVertices[i].z < minZ)
{
minZ = inputVertices[i].z;
}
}
//Needed to transform the position of our 2 dimensions mentioned above into a single array.
//The indexes look like this: 0_X, 0_Y, 0_Z, 0_?, 1_X, 1_Y, 1_Z.... Where 0,1 etc stand for the vertex number
//X,Y,Z stands for the respective coordinates and ? is just a placeholder which is not really needed (but we need to have a power of 2 so 4 values for our 3)
int maxHeight = linesVector.Length;
for (int i = 0; i < numberOfVertices; i++)
{
//We use the lines produced above to calculate the new position
int index = linesVertices[i] * maxHeight;
//We interpret the values as probabilities. And the amplitudes are the square root of the probabilities.
circuit.Amplitudes[index + linesVector[0]].Real = Math.Sqrt(inputVertices[i].x - minX);
circuit.Amplitudes[index + linesVector[1]].Real = Math.Sqrt(inputVertices[i].y - minY);
circuit.Amplitudes[index + linesVector[2]].Real = Math.Sqrt(inputVertices[i].z - minZ);
}
//We need to normalize the circuit, since probabilities should add up to 1.
//We store the factor used for normalization in order to reverse this scaling later.
circuit.Normalize();
double normalizationFactor = circuit.OriginalSum;
//We don't want to allocate as phew memory as possible in order to minimize garbage collection
//Therefore, we reuse the defined arrays
double[] realAmplitudes = new double[circuit.AmplitudeLength];
Vector3[] outPutVertices = new Vector3[numberOfVertices];
//Making a copy of the amplitudes of the circuit
for (int i = 0; i < circuit.AmplitudeLength; i++)
{
realAmplitudes[i] = circuit.Amplitudes[i].Real;
}
//Creating a new mesh, at this point it is just a copy of the input mesh
Mesh outputMesh = new Mesh();
outputMesh.name = InputMesh.name + " blurred";
outputMesh.vertices = inputVertices;
outputMesh.triangles = InputMesh.triangles;
outputMesh.uv = InputMesh.uv;
outputMesh.RecalculateNormals();
outputMesh.RecalculateTangents();
MicroQiskitSimulator simulator = new MicroQiskitSimulator();
double[] probs = new double[circuit.AmplitudeLength]; //simulator.GetProbabilities(circuit);
ComplexNumber[] amplitudes = new ComplexNumber[circuit.AmplitudeLength];
//Setting the new mesh to the target
//We can now just manipulate the vertices of this mesh in order to change it.
//No need to create new meshes
TargetMesh.sharedMesh = outputMesh;
OutputMesh = outputMesh;
float rotation = 0.0f;
float progress = 0;
//Making sure to have no endless loop
if (Duration <= 0)
{
Duration = 1;
}
//Creating an animation by blurring the mesh step by step
//Duration is the duration of the animation, StartRotation and Endrotation give
//The starting points and endpoints of the animation the rest is interpolated.
while (progress < 1)
{
//Calculating progress for the animation
progress += Time.deltaTime / Duration;
//Rotation is interpolated between endRotation and startRtoation depending on progress
rotation = progress * EndRotation + (1 - progress) * StartRotation;
//Resetting the circuit (deleting the gates)
circuit.ResetGates();
//Reusing the circuit by filling in the original values before the calculation again
for (int i = 0; i < circuit.AmplitudeLength; i++)
{
circuit.Amplitudes[i].Real = realAmplitudes[i];
}
//Applying the operation to the circuit (the blur effect)
ApplyPartialQ(circuit, rotation);
//Calculating probabilities
simulator.CalculateProbabilities(circuit, ref probs, ref amplitudes);
//Filling in the new calculated values into the vertices
for (int i = 0; i < numberOfVertices; i++)
{
int index = linesVertices[i] * maxHeight;
//Since we have probabilities already we do not need to square them.
//We undo the normalization from above and the translation (offset) from the beginning
outPutVertices[i].x = (float)(probs[index + linesVector[0]] * normalizationFactor) + minX;
outPutVertices[i].y = (float)(probs[index + linesVector[1]] * normalizationFactor) + minY;
outPutVertices[i].z = (float)(probs[index + linesVector[2]] * normalizationFactor) + minZ;
}
//We set the new vertices to the mesh, this way the mesh changes its form automatically
//and we do not need to construct a new mesh.
outputMesh.vertices = outPutVertices;
//wait until next frame.
yield return(null);
}
// Reverse animation going back to startRotation
if (reverseAnimation)
{
while (progress > 0)
{
//Calculating progress for the animation going back
progress -= Time.deltaTime / Duration;
//Rotation is interpolated between endRotation and startRtoation depending on progress
rotation = progress * EndRotation + (1 - progress) * StartRotation;
//Resetting the circuit (deleting the gates)
circuit.ResetGates();
//Reusing the circuit by filling in the original values before the calculation again
for (int i = 0; i < circuit.AmplitudeLength; i++)
{
circuit.Amplitudes[i].Real = realAmplitudes[i];
}
//Applying the operation to the circuit (the blur effect)
ApplyPartialQ(circuit, rotation);
//Calculating probabilities
simulator.CalculateProbabilities(circuit, ref probs, ref amplitudes);
//Filling the new calculated values into the vertices
for (int i = 0; i < numberOfVertices; i++)
{
int index = linesVertices[i] * maxHeight;
//Since we have probabilities already we do not need to square them.
//We undo the normalization from above and the translation (offset) from the beginning
outPutVertices[i].x = (float)(probs[index + linesVector[0]] * normalizationFactor) + minX;
outPutVertices[i].y = (float)(probs[index + linesVector[1]] * normalizationFactor) + minY;
outPutVertices[i].z = (float)(probs[index + linesVector[2]] * normalizationFactor) + minZ;
}
outputMesh.vertices = outPutVertices;
//We set the new vertices to the mesh, this way the mesh changes its form automatically
//and we do not need to construct a new mesh.outputMesh.vertices = outPutVertices;
//wait until next frame.
yield return(null);
}
}
}
/// <summary>
/// Creates a blurred version of the input mesh, according to the rotation. The bigger the rotation the stronger the blur effect.
/// The model gets unrecognizeable as soon as the rotation gets to big
/// </summary>
/// <param name="inputMesh">The mesh to produce a blurred version of.</param>
/// <param name="rotation">Can be between 0 and 3.1415 (pi). For starting 0.1 would be a good value.</param>
/// <returns>A blurred (distorted) mesh of the original input mesh. </returns>
public Mesh CreateBluredMesh(Mesh inputMesh, float rotation)
{
//It is important to create a copy of the vertices and only use "inputMesh.vertices" only once
// since this is a get function. Meaning in every call of the function the mesh will be copied.
Vector3[] vertices = inputMesh.vertices;
int numberOfVertices = vertices.Length;
//We look at our input being 2 dimensional. One dimension is the number of vertices,
//the other dimension is the vector x,y,z
//We create lines for the first dimension the number of vertices
int numberOfVertexCubits = Mathf.CeilToInt(Mathf.Log(numberOfVertices) / Mathf.Log(2));
//The lines are needed to encode the data in a way that encoding of neighbouring vertices only differ in 1 bit
int[] linesVertices = QuantumImageHelper.MakeLinesInt(numberOfVertexCubits);
//We create lines for the second dimension the vector x,y,z so there are only 3 values (thats where the 3 comes from).
//The 2 is to transform the thing to base 2 since we need the logarithm in base 2.
int numberOfVectorQubits = Mathf.CeilToInt(Mathf.Log(3) / Mathf.Log(2));
//The lines are needed to encode the data in a way that the encoding of x and y as well as y and z only differ in 1 bit.
int[] linesVector = QuantumImageHelper.MakeLinesInt(numberOfVectorQubits);
//Creating a circuit big enough to fit in the mesh data
int numberOfQubits = numberOfVertexCubits + numberOfVectorQubits;
QuantumCircuit circuit = new QuantumCircuit(numberOfQubits, numberOfQubits, true);
//Since we work with probabilities, we need the values to be positive (or 0).
//Therefore we want to translate the values adding an offset to our values, such that they become positive.
//Getting the smallest (most negative) values to use for the displacement
//initiate values as 0
float minX = 0;
float minY = 0;
float minZ = 0;
for (int i = 0; i < vertices.Length; i++)
{
if (vertices[i].x < minX)
{
minX = vertices[i].x;
}
if (vertices[i].y < minY)
{
minY = vertices[i].y;
}
if (vertices[i].z < minZ)
{
minZ = vertices[i].z;
}
}
//Needed to transform the position of our 2 dimensions mentioned above into a single array.
//The indexes look like this: 0_X, 0_Y, 0_Z, 0_?, 1_X, 1_Y, 1_Z.... Where 0,1 etc stand for the vertex number
//X,Y,Z stands for the respective coordinates and ? is just a placeholder which is not really needed (but we need to have a power of 2 so 4 values for our 3)
int maxHeight = linesVector.Length;
for (int i = 0; i < numberOfVertices; i++)
{
//We use the lines produced above to calculate the new position
int index = linesVertices[i] * maxHeight;
//We interpret the values as probabilities. And the amplitudes are the square root of the probabilities.
circuit.Amplitudes[index + linesVector[0]].Real = Math.Sqrt(vertices[i].x - minX);
circuit.Amplitudes[index + linesVector[1]].Real = Math.Sqrt(vertices[i].y - minY);
circuit.Amplitudes[index + linesVector[2]].Real = Math.Sqrt(vertices[i].z - minZ);
}
//We need to normalize the circuit, since probabilities should add up to 1.
//We store the factor used for normalization in order to reverse this scaling later.
circuit.Normalize();
double normalizationFactor = circuit.OriginalSum;
//We apply the effect to the circuit. Here this is the normal blur effect also used in the images.
ApplyPartialQ(circuit, rotation);
//Calculating the probabilities after having applied the operation above
SimulatorBase simulator = new MicroQiskitSimulator();
//MicroQiskitSimulator simulator = new MicroQiskitSimulator();
//QiskitSimulator simulator = new QiskitSimulator();
double[] probs = simulator.GetProbabilities(circuit);
//Fill in the new calculated values back into the vertices
for (int i = 0; i < numberOfVertices; i++)
{
int index = linesVertices[i] * maxHeight;
//Since we have probabilities already we do not need to square them.
//We undo the normalization from above and the translation (offset) from the beginning
vertices[i].x = (float)(probs[index + linesVector[0]] * normalizationFactor) + minX;
vertices[i].y = (float)(probs[index + linesVector[1]] * normalizationFactor) + minY;
vertices[i].z = (float)(probs[index + linesVector[2]] * normalizationFactor) + minZ;
}
//creating the new mesh
Mesh outputMesh = new Mesh();
//setting the newly calculated vertices
outputMesh.vertices = vertices;
//Copying most stuff from original mesh
outputMesh.name = inputMesh.name + " blurred";
outputMesh.triangles = inputMesh.triangles;
outputMesh.uv = inputMesh.uv;
//Recalculating normals for correct lighning
outputMesh.RecalculateNormals();
//returning the mesh
return(outputMesh);
}
public Texture2D ApplyGates(Texture2D InputTexture1)
{
Texture2D outPutTexture;
//generating the quantum circuits encoding the color channels of the image
QuantumCircuit red;
QuantumCircuit green;
QuantumCircuit blue;
double[,] imageData = QuantumImageHelper.GetHeightArrayDouble(InputTexture1, ColorChannel.R);
if (UseSimpleEncoding)
{
red = QuantumImageHelper.ImageToCircuit(imageData);
}
else
{
red = QuantumImageHelper.HeightToCircuit(imageData);
}
imageData = QuantumImageHelper.GetHeightArrayDouble(InputTexture1, ColorChannel.G);
if (UseSimpleEncoding)
{
green = QuantumImageHelper.ImageToCircuit(imageData);
}
else
{
green = QuantumImageHelper.HeightToCircuit(imageData);
}
imageData = QuantumImageHelper.GetHeightArrayDouble(InputTexture1, ColorChannel.B);
if (UseSimpleEncoding)
{
blue = QuantumImageHelper.ImageToCircuit(imageData);
}
else
{
blue = QuantumImageHelper.HeightToCircuit(imageData);
}
//QuantumCircuit red = QuantumImageCreator.GetCircuitDirect(InputTexture1, ColorChannel.R);
//QuantumCircuit green = QuantumImageCreator.GetCircuitDirect(InputTexture1, ColorChannel.G);
//QuantumCircuit blue = QuantumImageCreator.GetCircuitDirect(InputTexture1, ColorChannel.B);
red.Gates = Gates;
blue.Gates = Gates;
green.Gates = Gates;
double[,] redData, greenData, blueData;
if (UseSimpleEncoding)
{
redData = QuantumImageHelper.CircuitToImage(red, InputTexture1.width, InputTexture1.height);
greenData = QuantumImageHelper.CircuitToImage(green, InputTexture1.width, InputTexture1.height);
blueData = QuantumImageHelper.CircuitToImage(blue, InputTexture1.width, InputTexture1.height);
}
else
{
redData = QuantumImageHelper.CircuitToHeight2D(red, InputTexture1.width, InputTexture1.height);
greenData = QuantumImageHelper.CircuitToHeight2D(green, InputTexture1.width, InputTexture1.height);
blueData = QuantumImageHelper.CircuitToHeight2D(blue, InputTexture1.width, InputTexture1.height);
}
outPutTexture = QuantumImageHelper.CalculateColorTexture(redData, greenData, blueData);
return(outPutTexture);
}
public Texture2D CreateBlur(Texture2D inputeTExture, float rotation)
{
Texture2D outPutTexture;
//generating the quantum circuits encoding the color channels of the image
QuantumCircuit red;
QuantumCircuit green;
QuantumCircuit blue;
double[,] imageData = QuantumImageHelper.GetHeightArrayDouble(inputeTExture, ColorChannel.R);
if (UseSimpleEncoding)
{
red = QuantumImageHelper.ImageToCircuit(imageData);
}
else
{
red = QuantumImageHelper.HeightToCircuit(imageData);
}
imageData = QuantumImageHelper.GetHeightArrayDouble(inputeTExture, ColorChannel.G);
if (UseSimpleEncoding)
{
green = QuantumImageHelper.ImageToCircuit(imageData);
}
else
{
green = QuantumImageHelper.HeightToCircuit(imageData);
}
imageData = QuantumImageHelper.GetHeightArrayDouble(inputeTExture, ColorChannel.B);
if (UseSimpleEncoding)
{
blue = QuantumImageHelper.ImageToCircuit(imageData);
}
else
{
blue = QuantumImageHelper.HeightToCircuit(imageData);
}
//QuantumCircuit red = QuantumImageCreator.GetCircuitDirect(InputTexture1, ColorChannel.R);
//QuantumCircuit green = QuantumImageCreator.GetCircuitDirect(InputTexture1, ColorChannel.G);
//QuantumCircuit blue = QuantumImageCreator.GetCircuitDirect(InputTexture1, ColorChannel.B);
//applying the rotation generating the blur effect
ApplyPartialQ(red, rotation);
ApplyPartialQ(green, rotation);
ApplyPartialQ(blue, rotation);
Gates = red.Gates;
double[,] redData, greenData, blueData;
if (UseSimpleEncoding)
{
redData = QuantumImageHelper.CircuitToImage(red, inputeTExture.width, inputeTExture.height, RenormalizeImage);
greenData = QuantumImageHelper.CircuitToImage(green, inputeTExture.width, inputeTExture.height, RenormalizeImage);
blueData = QuantumImageHelper.CircuitToImage(blue, inputeTExture.width, inputeTExture.height, RenormalizeImage);
}
else
{
redData = QuantumImageHelper.CircuitToHeight2D(red, inputeTExture.width, inputeTExture.height, RenormalizeImage);
greenData = QuantumImageHelper.CircuitToHeight2D(green, inputeTExture.width, inputeTExture.height, RenormalizeImage);
blueData = QuantumImageHelper.CircuitToHeight2D(blue, inputeTExture.width, inputeTExture.height, RenormalizeImage);
}
outPutTexture = QuantumImageHelper.CalculateColorTexture(redData, greenData, blueData);
return(outPutTexture);
}
