|
No worries, I just saw the little code snippet and I don't know what your requirements are. My knee jerk reaction was that there has to be a simpler way of doing this.
Btw, there is a standard WeakEventManager inside .NET (first intoduced in 3.0)
WeakEventManager Class (System.Windows)[^]
|
|
|
|
|
It's not supported by the PCL!!!
But no worries, it's simple enough to implement that I made my own PCL version! 
|
|
|
|
|
|
|
How to connect MySQL to datagridview, project in Visual Studio 2015 with C#. 
|
|
|
|
|
You need to learn to do the minimum research [^]before asking a question.
Never underestimate the power of human stupidity
RAH
|
|
|
|
|
There are many things wrong with this question:
- The question implies you have no experience at all in software development. One of the most important rules is "seperation of concerns". Basically you divide a problem in smaller problems and solve them one by one. In this case, connecting database records directly to a grid is just not done.
- The question implies you have not done any research on the subject, which also implies you're taking the easy road.
- You have not even read this forum's guidelines[^]
To answer your question and hoping you will first start reading a book or getting some classes before diving in database development:
1.
You need to create some sort of DAL (DataAccess Layer) that will connect to the database and is able to perform several actions (CRUD eg, look that up in google). In your case getting data back into the application. One of my articles explains this and has sample code.
Building a Framework - Part I (DAL)[^]
2.
Once you have the data you should not connect it to the grid directly, rather create underlying objects that are useful. These objects can do little (just copy data to the object) or a lot (combining data, checking, reformatting, ...). That is done in the BLL (Business Logic Layer).
3.
Finally, when you have done that and you have a desirable list of objects you can bind that to the grid in the GUI (Graphical User Interface).
This is about the most basic (3-tier) model you can do, there are many more additional models/layers, design patterns you can add/do.
Seriously, if your intent is to go for a professional career, start out with the "hello world" program and build up from there.
hope this helps.
|
|
|
|
|
1. Make SQL connection via code, use a reader
2. Populate a collection of objects (classes) with the details you want on the grid
3. Bind the collection to the grid
<tag>I have no tag
|
|
|
|
|
when i run this code i was able to see the application but when choose the file to load an exception error occurs i.e system.badimagee exception error (not a valid win32 application) .
I need to load .poly files or .png help me out please
|
|
|
|
|
This is not a good question - we cannot work out from that little what you are trying to do.
Remember that we can't see your screen, access your HDD, or read your mind.
And what you have done so far is ring up the garage, say "my car broke" and put the phone down... How long do you think you will be waiting beside the road in the middle of nowhere until they turn up with exactly the right part to fix your car? 
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using Microsoft.DirectX;
namespace ScoOteRLoAdeR
{
struct Point
{
public List<double> Data;
public float NormalX, NormalY, NormalZ;
public Point(int DummyVariableForSatisfactionOfStupidCGarbageCompiler)
{
Data = new List<double>();
NormalX = NormalY = NormalZ = 0.0f;
}
}
struct Edge
{
public int Point1Index, Point2Index;
}
struct Face
{
public int Edge1Index, Edge2Index, Edge3Index;
}
struct Polygon
{
public int Face1Index, Face2Index;
}
struct Element
{
public List<int> PolygonsIndex;
public List<int> CubesIndex;
public string ZoneHeader;
public Element(int DummyVariableForSatisfactionOfStupidCGarbageCompiler)
{
PolygonsIndex = new List<int>();
CubesIndex = new List<int>();
ZoneHeader = "";
}
}
struct TriangulatedPolygon
{
public int Vertex1Index, Vertex2Index, Vertex3Index, Color;
}
struct TetrahardonatedCube
{
public int Vertex1Index, Vertex2Index, Vertex3Index, Vertex4Index;
}
struct BoundValues
{
public List<double> data;
public BoundValues(int DummyVariableForSatisfactionOfStupidCGarbageCompiler)
{
data = new List<double>();
}
}
enum type
{
Point,
Block
}
class ScoOteRParser
{
public BoundValues MaxValue;
public BoundValues MinValue;
protected List<Point> Points;
protected List<Edge> Edges;
protected List<Face> Faces;
protected List<TriangulatedPolygon> Facelets;
protected List<TetrahardonatedCube> Tetrahardons;
protected List<Polygon> Polygons;
protected List<MarchedCube> Cubes;
protected List<Element> Elements;
protected List<string> Variables;
private FileStream stream;
private StreamReader streamReader;
private string Title;
public ScoOteRParser()
{
ResetData();
}
public bool Load(string FileName)
{
stream = new FileStream(FileName, FileMode.Open);
streamReader = new StreamReader(stream);
string temp = ReadLine();
if (temp.Substring(0, 5) == "TITLE" || temp[0] == '"')
{
string[] tokens = temp.Split('"');
if (tokens.Length == 1)
Title = tokens[0];
else
Title = tokens[1];
temp = ReadLine();
}
if (temp.Substring(0, 9) == "VARIABLES")
{
temp = temp.Replace(" ", "");
string[] tokens = temp.Split('"');
Variables = new List<string>();
for (int i = 1; i < tokens.Length; i += 2)
{
Variables.Add(tokens[i]);
MaxValue.data.Add(double.MinValue);
MinValue.data.Add(double.MaxValue);
}
if (Variables.IndexOf("Z") == -1)
{
MaxValue.data.Add(double.MinValue);
MinValue.data.Add(double.MaxValue);
}
}
else
{
System.Windows.Forms.MessageBox.Show("Error Loading File\n The file might be corrupted or in the wrong format");
return false;
}
temp = ReadLine();
do
{
temp = temp.Replace(" ", "");
int TypeIndex = temp.IndexOf("F=");
string[] tokens = temp.Substring(TypeIndex).Split('=');
string ZoneHeader = temp.Remove(0, 4);
if (tokens[1].Substring(0, 5) == "POINT")
{
if (!ReadUnstructuredZone(ZoneHeader,type.Point))
return false;
}
else if (tokens[1].Substring(0, 5) == "BLOCK")
{
if (!ReadUnstructuredZone(ZoneHeader, type.Block))
return false;
}
else if (tokens[1].Substring(0, 7) == "FEPOINT")
{
if (!ReadFiniteElementZone(ZoneHeader,type.Point))
return false;
}
else if (tokens[1].Substring(0, 7) == "FEBLOCK")
{
if (!ReadFiniteElementZone(ZoneHeader,type.Block))
return false;
}
temp = ReadLine();
}
while(temp != null && temp.Substring(0,4) == "ZONE");
if (Variables.IndexOf("Z") == -1)
Variables.Insert(2, "Z");
streamReader.Close();
stream.Close();
return true;
}
#region Data Relation extraction functions
private void ReadPoints(int PointsNum)
{
string[] Tokens;
for (int LinesCounter = 0; LinesCounter < PointsNum; LinesCounter++)
{
Point p = new Point(13);
string temp = ReadLine();
Tokens = temp.Split(' ');
int VariablesCounter = 0;
foreach (string str in Tokens)
{
if (str == "")
continue;
if (VariablesCounter == 2 && Variables.IndexOf("Z") == -1)
p.Data.Add(0.0);
if (VariablesCounter == 2 && Variables.IndexOf("Z") != -1)
p.Data.Add(double.Parse(str) * -1);
else
p.Data.Add(double.Parse(str));
VariablesCounter++;
}
Points.Add(p);
CheckMaxMin(p);
}
}
private void ReadBlock(int PointsNum)
{
string[] Tokens;
for (int i = 0; i < PointsNum; i++)
{
Point p = new Point(13);
Points.Add(p);
}
for (int VariablesCounter = 0; VariablesCounter < Variables.Count; VariablesCounter++)
{
int CurrentPointsCount = 0;
if (VariablesCounter == 2 && Variables.IndexOf("Z") == -1)
for (int i = 0; i < Points.Count; i++)
Points[i].Data.Add(0.0);
else
while (CurrentPointsCount < PointsNum)
{
string temp = ReadLine();
Tokens = temp.Split(' ');
foreach (string str in Tokens)
{
if (str == "")
continue;
if (VariablesCounter == 2 && Variables.IndexOf("Z") != -1)
Points[CurrentPointsCount].Data.Add(double.Parse(str) * -1);
else
Points[CurrentPointsCount].Data.Add(double.Parse(str));
CurrentPointsCount++;
}
}
}
foreach(Point p in Points)
CheckMaxMin(p);
}
private bool ReadUnstructuredZone(string ZoneHeader, type Type)
{
int Maxi = 0;
int Maxj = 0;
int Maxk = 0;
int FirstPoint = Points.Count;
Element element = new Element(13);
element.ZoneHeader = ZoneHeader;
#region Parsing Zone Header
string[] Tokens = ZoneHeader.Split(',');
foreach (string str in Tokens)
{
if (str == "")
continue;
if (str[0] == 'I')
{
Maxi = int.Parse(str.Substring(2));
}
else if (str[0] == 'J')
{
Maxj = int.Parse(str.Substring(2));
}
else if (str[0] == 'K')
{
Maxk = int.Parse(str.Substring(2));
}
}
#endregion
#region Reading point
Maxk = (Maxk == 0) ? 1 : Maxk;
int PointsNum = Maxi * Maxj * Maxk;
if (Type == type.Point)
{
ReadPoints(PointsNum);
}
else
{
ReadBlock(PointsNum);
}
#endregion
#region Constructing DataStructure
for (int k = 0; k < Maxk ; k++)
{
for (int j = 0; j < Maxj - 1; j++)
{
for (int i = 0; i < Maxi - 1; i++)
{
Face face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)));
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1, i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)));
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
Polygon poly = new Polygon();
poly.Face1Index = Faces.Count - 2;
poly.Face2Index = Faces.Count - 1;
Polygons.Add(poly);
element.PolygonsIndex.Add(Polygons.Count - 1);
#region Generating The Cube Relation
if (Maxk > 1 && k < Maxk - 1)
{
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)));
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1, i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)));
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
poly = new Polygon();
poly.Face1Index = Faces.Count - 2;
poly.Face2Index = Faces.Count - 1;
Polygons.Add(poly);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1, i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
poly = new Polygon();
poly.Face1Index = Faces.Count - 2;
poly.Face2Index = Faces.Count - 1;
Polygons.Add(poly);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j));
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)));
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)));
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)));
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)));
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)));
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
poly = new Polygon();
poly.Face1Index = Faces.Count - 2;
poly.Face2Index = Faces.Count - 1;
Polygons.Add(poly);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j));
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1, i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
poly = new Polygon();
poly.Face1Index = Faces.Count - 2;
poly.Face2Index = Faces.Count - 1;
Polygons.Add(poly);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)));
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)), i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1);
face.Edge2Index = AddEdge(i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)), i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1);
face.Edge3Index = AddEdge(i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1, i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
poly = new Polygon();
poly.Face1Index = Faces.Count - 2;
poly.Face2Index = Faces.Count - 1;
Polygons.Add(poly);
element.PolygonsIndex.Add(Polygons.Count - 1);
MarchedCube c = new MarchedCube();
c.Vertex1 = i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j);
c.Vertex2 = i + FirstPoint + (Maxi * Maxj * k) + (Maxi * j) + 1;
c.Vertex3 = i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j) + 1;
c.Vertex4 = i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * j);
c.Vertex5 = i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1));
c.Vertex6 = i + FirstPoint + (Maxi * Maxj * k) + (Maxi * (j + 1)) + 1;
c.Vertex7 = i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1)) + 1;
c.Vertex8 = i + FirstPoint + (Maxi * Maxj * (k + 1)) + (Maxi * (j + 1));
Cubes.Add(c);
element.CubesIndex.Add(Cubes.Count - 1);
}
#endregion
}
}
}
#endregion
Elements.Add(element);
return true;
}
private bool ReadFiniteElementZone(string ZoneHeader, type Type)
{
int FirstPoint = Points.Count;
int PointsNum = 0;
int PolygonsNum = 0;
string PolygonType = "";
Element element = new Element(13);
element.ZoneHeader = ZoneHeader;
#region Parsing Zone Header
string[] Tokens = ZoneHeader.Split(',');
foreach (string str in Tokens)
{
if (str == "")
continue;
if (str[0] == 'N')
{
PointsNum = int.Parse(str.Substring(2));
}
else if (str.Substring(0, 2) == "ET")
{
PolygonType = str.Substring(3);
}
else if (str[0] == 'E' )
{
PolygonsNum = int.Parse(str.Substring(2));
}
}
#endregion
#region Reading point
if (Type == type.Point)
{
ReadPoints(PointsNum);
}
else
{
ReadBlock(PointsNum);
}
#endregion
#region Constructing DataStructure
Polygon polygon = new Polygon();
for (int PolygonCount = 0; PolygonCount < PolygonsNum; PolygonCount++)
{
string temp = ReadLine();
if (PolygonType == "TRIANGLE")
{
int[] points = new int[3];
Tokens = temp.Split(' ');
int index = 0;
foreach (string str in Tokens)
{
if (str == "")
continue;
points[index] = int.Parse(str) - 1 + FirstPoint;
index++;
}
Face face = new Face();
face.Edge1Index = AddEdge(points[0], points[1]);
face.Edge2Index = AddEdge(points[0], points[2]);
face.Edge3Index = AddEdge(points[1], points[2]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
if (PolygonCount % 2 == 0)
{
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 1;
}
else
{
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
}
}
else if (PolygonType == "QUADRILATERAL" || PolygonType == "TETRAHEDRON")
{
int[] points = new int[4];
Tokens = temp.Split(' ');
int index = 0;
foreach (string str in Tokens)
{
if (str == "")
continue;
points[index] = int.Parse(str) - 1;
index++;
}
Face face = new Face();
face.Edge1Index = AddEdge(points[0], points[1]);
face.Edge2Index = AddEdge(points[0], points[2]);
face.Edge3Index = AddEdge(points[1], points[2]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[0], points[2]);
face.Edge2Index = AddEdge(points[0], points[3]);
face.Edge3Index = AddEdge(points[2], points[3]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 2;
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
}
else if (PolygonType == "BRICK")
{
int[] points = new int[8];
Tokens = temp.Split(' ');
int index = 0;
foreach (string str in Tokens)
{
if (str == "")
continue;
points[index] = int.Parse(str) - 1;
index++;
}
#region Creating the 6 faces of the brick
Face face = new Face();
face.Edge1Index = AddEdge(points[0], points[1]);
face.Edge2Index = AddEdge(points[0], points[2]);
face.Edge3Index = AddEdge(points[1], points[2]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[0], points[2]);
face.Edge2Index = AddEdge(points[0], points[3]);
face.Edge3Index = AddEdge(points[2], points[3]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 2;
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[4], points[5]);
face.Edge2Index = AddEdge(points[4], points[6]);
face.Edge3Index = AddEdge(points[5], points[6]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[4], points[6]);
face.Edge2Index = AddEdge(points[4], points[7]);
face.Edge3Index = AddEdge(points[6], points[7]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 2;
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[3], points[2]);
face.Edge2Index = AddEdge(points[3], points[6]);
face.Edge3Index = AddEdge(points[2], points[6]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[3], points[6]);
face.Edge2Index = AddEdge(points[3], points[7]);
face.Edge3Index = AddEdge(points[6], points[7]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 2;
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[0], points[1]);
face.Edge2Index = AddEdge(points[0], points[5]);
face.Edge3Index = AddEdge(points[1], points[5]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[0], points[5]);
face.Edge2Index = AddEdge(points[0], points[4]);
face.Edge3Index = AddEdge(points[5], points[4]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 2;
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[1], points[5]);
face.Edge2Index = AddEdge(points[1], points[6]);
face.Edge3Index = AddEdge(points[5], points[6]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[1], points[6]);
face.Edge2Index = AddEdge(points[1], points[2]);
face.Edge3Index = AddEdge(points[6], points[2]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 2;
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[0], points[4]);
face.Edge2Index = AddEdge(points[0], points[7]);
face.Edge3Index = AddEdge(points[4], points[7]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
face = new Face();
face.Edge1Index = AddEdge(points[0], points[7]);
face.Edge2Index = AddEdge(points[0], points[3]);
face.Edge3Index = AddEdge(points[7], points[3]);
Faces.Add(face);
SetFaceNormals(Faces.Count - 1);
polygon = new Polygon();
polygon.Face1Index = Faces.Count - 2;
polygon.Face2Index = Faces.Count - 1;
Polygons.Add(polygon);
element.PolygonsIndex.Add(Polygons.Count - 1);
MarchedCube c = new MarchedCube();
c.Vertex1 = points[0];
c.Vertex2 = points[1];
c.Vertex3 = points[2];
c.Vertex4 = points[3];
c.Vertex5 = points[4];
c.Vertex6 = points[5];
c.Vertex7 = points[6];
c.Vertex8 = points[7];
Cubes.Add(c);
element.CubesIndex.Add(Cubes.Count - 1);
#endregion
}
}
#endregion
Elements.Add(element);
return true;
}
#endregion
public virtual void Triangulate()
{
foreach (Element e in Elements)
{
if (e.ZoneHeader.Contains("TRIANGLE"))
{
for (int i = 0; i < e.PolygonsIndex.Count; i++)
{
TriangulatedPolygon triangle = new TriangulatedPolygon();
triangle.Vertex1Index = Edges[Faces[Polygons[e.PolygonsIndex[i]].Face1Index].Edge1Index].Point1Index;
triangle.Vertex2Index = Edges[Faces[Polygons[e.PolygonsIndex[i]].Face1Index].Edge1Index].Point2Index;
triangle.Vertex3Index = Edges[Faces[Polygons[e.PolygonsIndex[i]].Face1Index].Edge2Index].Point2Index;
Facelets.Add(triangle);
triangle = new TriangulatedPolygon();
triangle.Vertex1Index = Edges[Faces[Polygons[e.PolygonsIndex[i]].Face2Index].Edge1Index].Point1Index;
triangle.Vertex2Index = Edges[Faces[Polygons[e.PolygonsIndex[i]].Face2Index].Edge1Index].Point2Index;
triangle.Vertex3Index = Edges[Faces[Polygons[e.PolygonsIndex[i]].Face2Index].Edge2Index].Point2Index;
Facelets.Add(triangle);
}
}
else
{
for (int i = 0; i < e.PolygonsIndex.Count; i++)
{
int[] points = GetPolygonIndices(e.PolygonsIndex[i]);
if (points == null)
continue;
Point p = new Point(13);
for (int vars = 0; vars < Variables.Count; vars++)
{
p.Data.Add((double)(Points[points[0]].Data[vars] + Points[points[1]].Data[vars]
+ Points[points[2]].Data[vars] + Points[points[3]].Data[vars]) / 4);
}
p.NormalX = Points[points[0]].NormalX;
p.NormalY = Points[points[0]].NormalY;
p.NormalZ = Points[points[0]].NormalZ;
Points.Add(p);
TriangulatedPolygon[] triangles = new TriangulatedPolygon[4];
triangles[0] = new TriangulatedPolygon();
triangles[0].Vertex1Index = points[0];
triangles[0].Vertex2Index = points[1];
triangles[0].Vertex3Index = Points.Count - 1;
triangles[1] = new TriangulatedPolygon();
triangles[1].Vertex1Index = points[1];
triangles[1].Vertex2Index = points[2];
triangles[1].Vertex3Index = Points.Count - 1;
triangles[2] = new TriangulatedPolygon();
triangles[2].Vertex1Index = points[2];
triangles[2].Vertex2Index = points[3];
triangles[2].Vertex3Index = Points.Count - 1;
triangles[3] = new TriangulatedPolygon();
triangles[3].Vertex1Index = points[3];
triangles[3].Vertex2Index = points[0];
triangles[3].Vertex3Index = Points.Count - 1;
Facelets.AddRange(triangles);
}
}
}
}
public void Tetrahardonate()
{
Tetrahardons = new List<TetrahardonatedCube>();
for (int i = 0 ; i < Cubes.Count; i++)
{
Point temp = new Point(13);
int [] points = GetCubeIndicies(i);
for (int vars = 0; vars < Variables.Count; vars ++)
{
temp.Data.Add((Points[points[0]].Data[vars] + Points[points[1]].Data[vars]
+ Points[points[2]].Data[vars] + Points[points[3]].Data[vars]
+ Points[points[4]].Data[vars] + Points[points[5]].Data[vars]
+ Points[points[6]].Data[vars] + Points[points[7]].Data[vars]) / 8);
}
Points.Add(temp);
TetrahardonatedCube t = new TetrahardonatedCube();
t.Vertex1Index = points[0];
t.Vertex2Index = points[1];
t.Vertex3Index = points[2];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[0];
t.Vertex2Index = points[2];
t.Vertex3Index = points[3];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[0];
t.Vertex2Index = points[3];
t.Vertex3Index = points[4];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[3];
t.Vertex2Index = points[4];
t.Vertex3Index = points[7];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[4];
t.Vertex2Index = points[5];
t.Vertex3Index = points[6];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[4];
t.Vertex2Index = points[6];
t.Vertex3Index = points[7];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[1];
t.Vertex2Index = points[2];
t.Vertex3Index = points[5];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[2];
t.Vertex2Index = points[5];
t.Vertex3Index = points[6];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[0];
t.Vertex2Index = points[1];
t.Vertex3Index = points[5];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[0];
t.Vertex2Index = points[5];
t.Vertex3Index = points[4];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[3];
t.Vertex2Index = points[2];
t.Vertex3Index = points[6];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
t = new TetrahardonatedCube();
t.Vertex1Index = points[3];
t.Vertex2Index = points[6];
t.Vertex3Index = points[7];
t.Vertex4Index = Points.Count - 1;
Tetrahardons.Add(t);
}
}
public List<TriangulatedPolygon> FACELETS
{
get { return Facelets; }
}
public List<TetrahardonatedCube> TETRAHARDONS
{
get { return Tetrahardons; }
}
public List<MarchedCube> CUBES
{
get { return Cubes; }
}
public List<Point> POINTS
{
get { return Points; }
}
#region HelperFunctions
private void ResetData()
{
Points = new List<Point>();
Edges = new List<Edge>();
Faces = new List<Face>();
Facelets = new List<TriangulatedPolygon>();
Polygons = new List<Polygon>();
Cubes = new List<MarchedCube>();
Elements = new List<Element>();
MaxValue = new BoundValues(13);
MinValue = new BoundValues(13);
}
private string ReadLine()
{
string str = streamReader.ReadLine();
Zeft: while (str == "" || str == string.Empty)
{
str = streamReader.ReadLine();
}
while (str != null && str[0] == ' ')
{
str = str.Remove(0, 1);
if (str == "")
goto Zeft;
}
return (str != null )?str.ToUpper():null;
}
private void CheckMaxMin(Point p)
{
if (p.Data[0] >= MaxValue.data[0] && p.Data[1] >= MaxValue.data[1] && p.Data[2] >= MaxValue.data[2])
{
MaxValue.data[0] = p.Data[0];
MaxValue.data[1] = p.Data[1];
MaxValue.data[2] = p.Data[2];
}
if (p.Data[0] <= MinValue.data[0] && p.Data[1] <= MinValue.data[1] && p.Data[2] <= MinValue.data[2])
{
MinValue.data[0] = p.Data[0];
MinValue.data[1] = p.Data[1];
MinValue.data[2] = p.Data[2];
}
for (int i = 3; i < p.Data.Count; i++)
{
if (p.Data[i] >= MaxValue.data[i])
MaxValue.data[i] = p.Data[i];
if (p.Data[i] <= MinValue.data[i])
MinValue.data[i] = p.Data[i];
}
}
private int AddEdge(int Index1, int Index2)
{
Edge e = new Edge();
e.Point1Index = Index1;
e.Point2Index = Index2;
int index = Edges.IndexOf(e);
if (index == -1)
{
Edges.Add(e);
return Edges.Count - 1;
}
return index;
}
private int[] GetPolygonIndices(int PolygonIndex)
{
int[] temp = new int[4];
temp[0] = Edges[Faces[Polygons[PolygonIndex].Face1Index].Edge1Index].Point1Index;
temp[1] = Edges[Faces[Polygons[PolygonIndex].Face1Index].Edge1Index].Point2Index;
temp[2] = Edges[Faces[Polygons[PolygonIndex].Face1Index].Edge2Index].Point2Index;
temp[3] = Edges[Faces[Polygons[PolygonIndex].Face2Index].Edge3Index].Point2Index;
return temp;
}
private int[] GetCubeIndicies(int CubeIndex)
{
int[] CubeIndecies = new int[8];
CubeIndecies[0] = Cubes[CubeIndex].Vertex1;
CubeIndecies[1] = Cubes[CubeIndex].Vertex2;
CubeIndecies[2] = Cubes[CubeIndex].Vertex3;
CubeIndecies[3] = Cubes[CubeIndex].Vertex4;
CubeIndecies[4] = Cubes[CubeIndex].Vertex5;
CubeIndecies[5] = Cubes[CubeIndex].Vertex6;
CubeIndecies[6] = Cubes[CubeIndex].Vertex7;
CubeIndecies[7] = Cubes[CubeIndex].Vertex8;
return CubeIndecies;
}
private void SetFaceNormals(int FaceIndex)
{
Point p1 = Points[Edges[Faces[FaceIndex].Edge1Index].Point1Index];
Point p2 = Points[Edges[Faces[FaceIndex].Edge2Index].Point2Index];
Point p3 = Points[Edges[Faces[FaceIndex].Edge3Index].Point1Index];
if (p1.NormalX == 0 && p1.NormalY == 0 && p1.NormalZ == 0)
{
Vector3 v1 = new Vector3((float)(p2.Data[0] - p1.Data[0]),
(float)(p2.Data[1] - p1.Data[1]),
(float)(p2.Data[2] - p1.Data[2]));
Vector3 v2 = new Vector3((float)(p3.Data[0] - p1.Data[0]),
(float)(p3.Data[1] - p1.Data[1]),
(float)(p3.Data[2] - p1.Data[2]));
v1 = Vector3.Cross(v2, v1);
v1.Normalize();
p1.NormalX = v1.X;
p1.NormalY = v1.Y;
p1.NormalZ = v1.Z;
Points[Edges[Faces[FaceIndex].Edge1Index].Point1Index] = p1;
}
if (p2.NormalX == 0 && p2.NormalY == 0 && p2.NormalZ == 0)
{
Vector3 v1 = new Vector3((float)(p1.Data[0] - p2.Data[0]),
(float)(p1.Data[1] - p2.Data[1]),
(float)(p1.Data[2] - p2.Data[2]));
Vector3 v2 = new Vector3((float)(p3.Data[0] - p2.Data[0]),
(float)(p3.Data[1] - p2.Data[1]),
(float)(p3.Data[2] - p2.Data[2]));
v1 = Vector3.Cross(v1, v2);
v1.Normalize();
p2.NormalX = v1.X;
p2.NormalY = v1.Y;
p2.NormalZ = v1.Z;
Points[Edges[Faces[FaceIndex].Edge2Index].Point2Index] = p2;
}
if (p3.NormalX == 0 && p3.NormalY == 0 && p3.NormalZ == 0)
{
Vector3 v1 = new Vector3((float)(p1.Data[0] - p3.Data[0]),
(float)(p1.Data[1] - p3.Data[1]),
(float)(p1.Data[2] - p3.Data[2]));
Vector3 v2 = new Vector3((float)(p2.Data[0] - p3.Data[0]),
(float)(p2.Data[1] - p3.Data[1]),
(float)(p2.Data[2] - p3.Data[2]));
v1 = Vector3.Cross(v2, v1);
v1.Normalize();
p3.NormalX = v1.X;
p3.NormalY = v1.Y;
p3.NormalZ = v1.Z;
Points[Edges[Faces[FaceIndex].Edge3Index].Point1Index] = p3;
}
}
protected void InverseNormals()
{
for (int i = 0; i < Points.Count; i++)
{
Point p = Points[i];
p.NormalX *= -1;
p.NormalY *= -1;
p.NormalZ *= -1;
Points[i] = p;
}
}
#endregion
}
}
when i am running the proect it works, but when i choose file (.poly) to load in application error(
Index and length must refer to a location within the string.
Parameter name: length ) appears
|
|
|
|
|
That's too much code to go through. You should have only shared relevant code and marked the line where the error is.
Looking at the message, you are trying to read a character at some location in the string. The location index is larger than string length. Following demonstrates what you are doing, somewhere in your code:
string hello = "hello";
char someCharacter = hello[10];
"You'd have to be a floating database guru clad in a white toga and ghandi level of sereneness to fix this goddamn clusterfuck.", BruceN[ ^]
|
|
|
|
|
Well, there you go - lots of places where you use Substring but don't check to see if you have strings of that length. You know, as each of these tests appears to start at the first character, you could just use StartsWith instead. If you don't do that, you're going to have to check the length of the string in each case.
This space for rent
|
|
|
|
|
Member 12301443 wrote: when i run this code
Which code? You didn't show any. If you're referring to the code of some article here on CodeProject then you chose the wrong forum: Post your question on the message board of the article instead (which you'll find at the bottom of its page).
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
That'l teech ya, have a code dump to play with. (see the reply to OG)
Never underestimate the power of human stupidity
RAH
|
|
|
|
|
uhh 
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
|
|
|
|
|
And "dump" is the right word: a quick scan and "goto" leaps out at me. 
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
|
|
|
|
|
Hello, dear forum.
I have a problem programming on C#. My recent activities with C++ are back over 20 years.
I downloaded from the internet a server/client-solution for SQLite and am stuck in my C#-application using this dll.
HRESULT hr;
HMODULE hMod = NULL;
PDLLGETCLASSOBJECT proc = NULL;
IClassFactory* pFactory = NULL;
hMod = GetModule( szDllPath );
if( !hMod ) return( false );
proc = (PDLLGETCLASSOBJECT) GetProcAddress( hMod, "DllGetClassObject" );
if( !proc ) return( false );
hr = proc( IInterface , IID_IClassFactory , (void**)&Factory );
if( hr || !pFactory ) return( false );
hr = pFactory->CreateInstance( NULL, IInterface , pInterface );
if( hr || !pInterface ) return( false );
pFactory->Release();
What I've done so far (not much):
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode]
private static extern IntPtr LoadLibrary(String lpFileName);
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true)]
private static extern IntPtr GetProcAddress(IntPtr hModule, String procName);
[DllImport("kernel32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern Boolean FreeLibrary(IntPtr hModule);
...
private static String DLLFile = string.Empty;
private static IntPtr handleDLL = IntPtr.Zero;
private static IntPtr handleProc = IntPtr.Zero;
...
DLLFile = MyPath + @"Lib\SQLQueryAS.dll";
handleDLL = LoadLibrary(DLLFile);
if (handleDLL == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
handleProc = GetProcAddress(handleDLL, "DllGetClassObject");
if (handleProc == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
???
and now
???
Then (unless I have understood correctly) it should invite a class, so you can responsive in this class located methods (procs/functions).
Please help me. What should happen next?
Thank you in advance.
modified 2-Mar-16 17:05pm.
|
|
|
|
|
There is a .NET specific assembly available for download[^], which means you don't need C++.
You open a SQLiteConnection and issue a SQLiteCommand 
Bastard Programmer from Hell 
If you can't read my code, try converting it here[^]
|
|
|
|
|
Thank you for answering.
My intention is a Server/Client solution, where the Server is on another remote machine than the Client. IMHO the System.Data.SQLite does not support this. Or am I totaly wrong with the mentioned dll?
|
|
|
|
|
This sounds a bit weird. If the server is on another machine, the client should "protect" you from the fact that you're dealing with a database.
If you want to use Sqlite (and connect to such a db) on a remote machine, I have never tried such a scenario, but seems to defeat the purpose of sqlite. In other words, the whole purpose of sqlite is to keep everything into a file which it can access really fast at any time. If that file is remote, that guarantee is gone.
Best,
John
-- Log Wizard - a Log Viewer that is easy and fun to use!
|
|
|
|
|
John is correct, you are using the wrong tool for the job. Trying to use a single user, local database as a server database. Use a server database!
Never underestimate the power of human stupidity
RAH
|
|
|
|
|
Thank you for participating in my question.
Of course, you ALL are right with the (ab)use of SQLite for such a task.
But there are in the market some providers of such scenarios, unfortunately, to pay what separates for my hobby.
Therefore I've decided for this supplier, which is for free.
Please, let's go away from the theme SQLite, at all from the theme database.
My original question was how to reconstruct the functionality of a language (C++) in another language (C#).
To use a DLL with embedded class ...
Is there even any further help?
Thank you.
|
|
|
|
|
You should go back and read Eddy Vluggen's response. You do not need to reproduce anything from C++, you just need to use the .NET assembly that supports SQLite. If you then want to separate your database from your client application, you can use a socket connection between the two C# programs.
|
|
|
|
|
If you want to go that route, first off, it matters a lot if the functions you want to use are C functions, or C++ functions.
If they are C functions, you're in luck. Otherwise, each (member-)function will be really weirdly mangled by the compiler into and it will be really really painful to use.
Assuming we're in the C-functions area, you don't really need to complicate yourself with loading the library and such.
What I suggest is to bring the dll you need into a path that is auto-recognized by the OS - simplest one - your application path, where your executable is.
Then, you can import C-functions the pinvoke[^] way.
More info here[^] and here[^]
If you're lucky, you can use this tool[^] to convert all your dll functions into C# function calls.
More tools available here[^].
-- Log Wizard - a Log Viewer that is easy and fun to use!
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
