public void TestExternalBaseSurrogate()
{
var x = new CMySuperStd
{
Name = "Alyssa",
Age = 21,
Sex = "Yes"
};
var c = new CSerializationContext();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(3, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
Assert.AreEqual(x.Sex, XmlExtensions.GetElementValue(elem, "Sex"), "Sex");
PrintLine();
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(1, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetAttributeValue(elem, "NAME"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetAttributeValue(elem, "AGE"), "Age");
Assert.AreEqual(x.Sex, XmlExtensions.GetElementValue(elem, "Sex"), "Sex");
}
public void TestGenericDerived()
{
var src = new CPersonWithObject <CAddress>()
{
SomeObject = new CAddress()
{
m_city = "Spring",
m_street = "Halifax",
m_zip = 37174
}
};
var s = new CSerializer();
var xml = s.Serialize(src);
Print(xml);
var d = new CDeserializer();
var dest = d.Deserialize(xml) as CPersonWithObject <CAddress>;
Assert.AreEqual(src.m_name, dest.m_name, "Name");
Assert.AreEqual(src.SomeObject.m_street, dest.SomeObject.m_street, "Generic Street");
Assert.AreEqual(src.m_address.m_zip, dest.m_address.m_zip, "Zip");
Assert.AreNotEqual(src.SomeObject, dest.SomeObject);
}
public void TestArraySurrogate()
{
var x = new int[] { 1, 3, 5, 7, 9 };
var c = new CSerializationContext();
c.SetConcise();
var helper = new CIntArraySurrogate();
c.RegisterExternalSurrogate(typeof(int[]), helper);
var s = new CSerializer(c);
var doc = s.Serialize(x);
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var y = (int[])d.Deserialize(doc);
Assert.AreEqual(x.Length, y.Length - 1, "Length of resulting array is wrong");
for (var i = 0; i < x.Length; i++)
{
Assert.AreEqual(x[i], y[i], "Invalid element at: " + i);
}
}
public void TestStringCounter()
{
var x = new CTypeCounter();
var c = new CSerializationContext();
c.SetConcise();
c.RegisterExternalSurrogate(typeof(string), x);
var s = new CSerializer(c);
var doc = s.Serialize(x);
Assert.AreEqual(3, x.Count, "There should have been 3 strings counted.");
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var y = d.Deserialize <CTypeCounter>(doc);
Assert.AreEqual(0, y.Count, "The new object should have no counted strings");
Assert.AreEqual(6, x.Count, "The initial object should have strings counted for 2 actions");
}
public bool MySerialize(CSerializer _framework, XmlNode _node)
{
XmlExtensions.AddAttribute(_node, "Incomplete", "Yes");
STATUS = ETestStatus.IMPLICIT_SERIALIZER_INCOMPLETE;
return(false);
}
public void TestExternalSurrogate()
{
var x = new CStdBaseObject
{
Name = "Alyssa",
Age = 21
};
var c = new CSerializationContext();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(2, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
Console.WriteLine(
"\r\n\r\n-----------------------------------------------------------------------------\r\n\r\n");
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(0, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetAttributeValue(elem, "NAME"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetAttributeValue(elem, "AGE"), "Age");
}
public void TestFieldRenamer()
{
var c = new CSerializationContext
{
FieldRenamer = new CFieldRenamer()
};
var s = new CSerializer(c);
var add = new CAddress();
var doc = s.Serialize(add);
Print(doc);
var root = doc.DocumentElement;
TestSingleRenamedField(add.m_zip, root["INT_Zip"]);
TestSingleRenamedField(add.m_city, root["STRING_City"]);
TestSingleRenamedField(add.m_street, root["STRING_Street"]);
var d = new CDeserializer(c);
var ad2 = d.Deserialize <CAddress>(doc);
Assert.AreEqual(add.m_city, ad2.m_city, "City");
Assert.AreEqual(add.m_street, ad2.m_street, "Street");
Assert.AreEqual(add.m_zip, ad2.m_zip, "Zip");
}
public void TestLinkedList()
{
var list = new LinkedList <int>();
for (var i = 1; i < 1000000; i = (int)((i + 1) * 1.5))
{
list.AddLast(i);
}
var s = new CSerializer();
var doc = s.Serialize(list);
Print(doc);
var d = new CDeserializer();
var list2 = d.Deserialize(doc) as LinkedList <int>;
Assert.AreEqual(list.Count, list2.Count, "Number of resulting elements is wrong.");
var ptr = list2.First;
foreach (var x in list)
{
Assert.AreEqual(x, ptr.Value, "The deserialized value is wrong for initial value: " + x);
ptr = ptr.Next;
}
}
public void TestDuplicateReferences()
{
var arr = new object[10];
var p = new CPerson();
var p2 = new CPerson();
arr[1] = p;
arr[2] = p2;
arr[5] = p2;
arr[8] = p;
arr[9] = p;
object x = arr;
var c = new CSerializationContext();
c.SetConcise();
c.FixM_ = true;
c.ArrayElementsIncludeIndicies = true;
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
AssureCorrectReference(elem, 1, 8);
AssureCorrectReference(elem, 1, 9);
AssureCorrectReference(elem, 2, 5);
}
public void TestStack()
{
var q = new Stack <CAddress>();
for (var i = 1; i < 11; i++)
{
q.Push(CAddress.Get());
}
var s = new CSerializer();
var doc = s.Serialize(q);
Print(doc);
var d = new CDeserializer();
var q2 = (Stack <CAddress>)d.Deserialize(doc);
Assert.AreEqual(q.Count, q2.Count, "Number of resulting elements is wrong.");
Assert.AreEqual(q.Count,
doc.DocumentElement.ChildNodes.Count,
"The number of child nodes does not equal the number of elements in the Collection.");
while (q.Count > 0)
{
var a1 = q.Pop();
var a2 = q2.Pop();
CompareCAddresses(a1, a2);
}
}
/// <summary>
/// 編集図面をシリアライズされたバッファから読み込む
/// </summary>
/// <param name="cad2d"></param>
protected void loadEditCad2DFromSerializedBuffer(ref CCadObj2D cad2d)
{
// 図面をクリア
cad2d.Clear();
// シリアライズバッファから図面を読み込む
if (SerializedCadObjBuff != "")
{
// Cadオブジェクト一時ファイルを作成
string tmpFilename = generateTmpFilename();
createDirectory(Path.GetDirectoryName(tmpFilename));
try
{
// シリアライズバッファを一時ファイルに出力する(Shift JIS)
using (StreamWriter sw = new StreamWriter(tmpFilename, false, Encoding.GetEncoding(932)))
{
sw.Write(SerializedCadObjBuff);
}
// 一時ファイルからCadオブジェクトにデータをロードする
using (CSerializer fin = new CSerializer(tmpFilename, true)) // is_loading:true
{
cad2d.Serialize(fin);
}
// 一時ファイルを削除する
File.Delete(tmpFilename);
}
catch (Exception exception)
{
System.Diagnostics.Debug.WriteLine(exception.Message + " " + exception.StackTrace);
MessageBox.Show(exception.Message);
}
}
}
/// <summary>
/// 図面をシリアライズバッファに保存する
/// </summary>
protected void saveEditCad2DToSerializedBuffer(CCadObj2D cad2d)
{
// シリアライズされたCadオブジェクトのバッファを削除
clearSerializedCadObjBuffer();
// Cadオブジェクト一時ファイルを作成
string tmpFilename = generateTmpFilename();
createDirectory(Path.GetDirectoryName(tmpFilename));
try
{
// 編集Cadオブジェクトをファイルに出力する
using (CSerializer fout = new CSerializer(tmpFilename, false)) // is_loading:false
{
cad2d.Serialize(fout);
}
// シリアライズしたCadオブジェクトをメモリにロードする
using (StreamReader sr = new StreamReader(tmpFilename, Encoding.GetEncoding(932)))
{
SerializedCadObjBuff = sr.ReadToEnd();
}
// 一時ファイルを削除する
File.Delete(tmpFilename);
}
catch (Exception exception)
{
System.Diagnostics.Debug.WriteLine(exception.Message + " " + exception.StackTrace);
MessageBox.Show(exception.Message);
}
System.Diagnostics.Debug.WriteLine("SerializedCadObjBuff size = {0}", SerializedCadObjBuff.Length);
}
public void TestNullableType()
{
int?x = null;
var s = new CSerializer();
CSerializationContext.Global.SetVerbose();
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(CSerializationContext.Global.NullAttributeValue,
XmlExtensions.GetAttributeValue(elem, CSerializationContext.Global.NullAttributeName),
"Should be null");
Assert.AreEqual("", elem.InnerText, "Should be no innerText");
PrintLine();
x = 69;
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(x.GetType().AssemblyQualifiedName,
XmlExtensions.GetAttributeValue(elem, CSerializationContext.Global.TypeAttributeName),
"The Type is wrong");
}
public void TestMultidimStringArray()
{
string[,] x;
x = (string[, ])Array.CreateInstance(typeof(string), new int[] { 2, 2 }, new int[] { 5, 9 });
x[5, 9] = "first";
x[5, 10] = "second";
x[6, 9] = "third";
x[6, 10] = "fourth";
var c = new CSerializationContext();
c.SetConcise();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(1, elem.ChildNodes.Count, "Should be one child (an XmlText node)");
Assert.AreEqual("2,2",
XmlExtensions.GetAttributeValue(elem, c.ArrayAttributeName),
"Array Lengths are wrong");
Assert.AreEqual("5,9",
XmlExtensions.GetAttributeValue(elem, c.ArrayLowerBoundAttribute),
"Array Lowerbounds are wrong");
Assert.AreEqual("first,second,third,fourth", elem.InnerText, "The text for the multidim array is wrong");
}
public void TestSuperclassedArray()
{
var x = new CSuperArray
{
Arr = new int[] { 1, 3, 5 }
};
var s = new CSerializer();
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(typeof(CSuperArray).AssemblyQualifiedName,
XmlExtensions.GetAttributeValue(elem, s.Context.TypeAttributeName),
"Type of the root node is wrong");
var e = (XmlElement)elem.SelectSingleNode("Arr");
Assert.IsNotNull(e, "Missing Arr element");
Assert.AreEqual(x.Arr.GetType().AssemblyQualifiedName,
XmlExtensions.GetAttributeValue(e, s.Context.TypeAttributeName),
"Type Attribute Error");
Assert.AreEqual(x.Arr.Length.ToString(),
XmlExtensions.GetAttributeValue(e, s.Context.ArrayAttributeName),
"Length of Array Attribute is wrong");
Assert.AreEqual("1,3,5", elem.InnerText, "Inner Text for the array");
}
public void TestConstructor()
{
var other = new CSerializationContext();
var s = new CSerializer(other);
ReferenceEquals(other, s.Context);
}
public void TestDictionary()
{
var x = new Dictionary <int, string>
{
[4] = "hello",
[55] = "Katie",
[15834] = "=)",
[324] = "Homer",
[-87] = "Simpson"
};
var c = new CSerializationContext();
c.SetConcise();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var d = new CDeserializer(c);
var y = (Dictionary <int, string>)d.Deserialize(doc);
Assert.AreEqual(x.Count, y.Count, "Size of resulting hashtable is wrong");
foreach (var key in x.Keys)
{
Assert.AreEqual(x[key], y[key], "Entry at key " + key + " was wrong.");
}
}
public void TestExternalSurrogate()
{
CBigPerson.GenerateData(100);
var c = new CSerializationContext();
c.SetConcise();
var helper = new CFriendSerializer();
c.RegisterExternalSurrogate(typeof(CFriend), helper);
var s = new CSerializer(c);
var doc = s.Serialize(CBigPerson.People);
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var x2 = d.Deserialize <CBigPerson[]>(doc);
helper.FinishDeserializing(x2);
CDeserializeTest.AssertEqualBigPeopleArray(CBigPerson.People, x2);
}
public void TestSortedDictionary()
{
var names = GenerateRandomNames();
var dict = new SortedDictionary <string, CAddress>();
for (var i = 0; i < 26; i++)
{
dict[names[i]] = CAddress.Get();
}
var s = new CSerializer();
var doc = s.Serialize(dict);
Print(doc);
var d = new CDeserializer();
var d2 = (SortedDictionary <string, CAddress>)d.Deserialize(doc);
Assert.AreEqual(dict.Count, d2.Count, "Size of resulting dictionary is wrong");
Assert.AreEqual(dict.Count, doc.DocumentElement.ChildNodes.Count, "The number of XmlNodes for the collection is wrong");
foreach (var key in dict.Keys)
{
CompareCAddresses(dict[key], d2[key]);
}
}
public void MySerialize(CSerializer _framework, XmlNode _node)
{
XmlExtensions.AddAttribute(_node, "NAME", Name);
XmlExtensions.AddAttribute(_node, "AGE", Age);
STATUS = ETestStatus.IMPLICIT_SERIALIZER_VOID;
}
public void TestConstructorWithNominalTypeAndObjectAndSerializerAndIsUpdateDocument()
{
var c = CreateC();
var serializer = new CSerializer();
var serializationOptions = DocumentSerializationOptions.SerializeIdFirstInstance;
var wrapper = new BsonDocumentWrapper(typeof(C), c, serializer, serializationOptions, true);
Assert.AreEqual(true, wrapper.IsUpdateDocument);
Assert.AreEqual(serializationOptions, wrapper.SerializationOptions);
Assert.AreSame(serializer, wrapper.Serializer);
Assert.AreSame(typeof(C), wrapper.WrappedNominalType);
Assert.AreSame(c, wrapper.WrappedObject);
Assert.AreEqual(false, wrapper.IsMaterialized);
wrapper = new BsonDocumentWrapper(typeof(C), null, serializer, serializationOptions, true);
Assert.AreEqual(true, wrapper.IsUpdateDocument);
Assert.AreEqual(serializationOptions, wrapper.SerializationOptions);
Assert.AreSame(serializer, wrapper.Serializer);
Assert.AreSame(typeof(C), wrapper.WrappedNominalType);
Assert.AreSame(null, wrapper.WrappedObject);
Assert.AreEqual(false, wrapper.IsMaterialized);
Assert.Throws <ArgumentNullException>(() => new BsonDocumentWrapper(null, c, serializer, serializationOptions, true));
Assert.Throws <ArgumentNullException>(() => new BsonDocumentWrapper(typeof(C), c, null, serializationOptions, true));
Assert.DoesNotThrow(() => new BsonDocumentWrapper(typeof(C), c, serializer, null, true));
}
public void TestList()
{
var names = new List <string>
{
"Homer",
"Marge",
"Bart",
"Lisa",
"Maggie"
};
var c = new CSerializationContext();
c.SetVerbose();
var s = new CSerializer(c);
var doc = s.Serialize(names);
Print(doc);
var d = new CDeserializer(c);
var names2 = d.Deserialize <List <string> >(doc);
Assert.AreEqual(names.Count, names2.Count, "The number of list elements is wrong");
for (var i = 0; i < names.Count; i++)
{
Assert.AreEqual(names[i], names2[i], "The name is wrong at index " + i);
}
}
public void TestAllArrayLists()
{
CClassWithArrayLists ca = new CClassWithArrayLists();
ca.SimpleArrayList = MakeSampleArrayList();
ca.ReadOnlyArrayList = ArrayList.ReadOnly(ca.SimpleArrayList);
// This is really bad because we shouldn't really hold the ref to the "old" object
// after its been wrapped
ca.SyncArrayList = ArrayList.Synchronized(ca.SimpleArrayList);
// This is really bad because we shouldn't really hold the ref to the "old" object
// after its been wrapped
Assert.AreNotEqual(ca.SimpleArrayList.GetType(),
ca.ReadOnlyArrayList.GetType(),
"The Type of the ArrayList is the SAME as the ReadOnly ArrayList.");
Assert.AreNotEqual(ca.SimpleArrayList.GetType(),
ca.SyncArrayList.GetType(),
"The Type of the ArrayList is the SAME as the SyncArrayList.");
Assert.AreNotEqual(ca.SyncArrayList.GetType(),
ca.ReadOnlyArrayList.GetType(),
"The Type of the SyncArrayList is the SAME as the ReadOnly ArrayList.");
Console.WriteLine(ca.SimpleArrayList.GetType().AssemblyQualifiedName);
Console.WriteLine(ca.ReadOnlyArrayList.GetType().AssemblyQualifiedName);
Console.WriteLine(ca.SyncArrayList.GetType().AssemblyQualifiedName);
CSerializationContext.Global.UseFullUtcDateTimeStrings = true;
CSerializer s = new CSerializer();
XmlDocument doc = s.Serialize(ca);
Print(doc);
CDeserializer d = new CDeserializer();
CClassWithArrayLists ca2 = d.Deserialize <CClassWithArrayLists>(doc);
Assert.AreEqual(ca.SimpleArrayList.GetType(),
ca2.SimpleArrayList.GetType(),
"The Type of the resulting ArrayList is different.");
Assert.AreEqual(ca.ReadOnlyArrayList.GetType(),
ca2.ReadOnlyArrayList.GetType(),
"The Type of the ReadOnly array is different");
Assert.AreEqual(ca.SyncArrayList.GetType(),
ca2.SyncArrayList.GetType(),
"The Type of the Sync array is different");
Assert.AreNotEqual(ca2.SimpleArrayList.GetType(),
ca2.ReadOnlyArrayList.GetType(),
"The Type of the ArrayList is the SAME as the ReadOnly ArrayList.");
Assert.AreNotEqual(ca2.SimpleArrayList.GetType(),
ca2.SyncArrayList.GetType(),
"The Type of the ArrayList is the SAME as the SyncArrayList.");
Assert.AreNotEqual(ca2.SyncArrayList.GetType(),
ca2.ReadOnlyArrayList.GetType(),
"The Type of the SyncArrayList is the SAME as the ReadOnly ArrayList.");
VerifyArrayListContents(ca.SimpleArrayList, ca2.SimpleArrayList);
VerifyArrayListContents(ca.ReadOnlyArrayList, ca2.ReadOnlyArrayList);
VerifyArrayListContents(ca.SyncArrayList, ca2.SyncArrayList);
}
public bool MySerialize(CSerializer _serializer, XmlNode _node)
{
XmlExtensions.AddAttribute(_node, "NAME", Name);
XmlExtensions.AddAttribute(_node, "AGE", Age);
STATUS = ETestStatus.IMPLICIT_SERIALIZER;
return(true);
}
public void TestConstructorNull()
{
var s = new CSerializer(null);
Assert.AreEqual(CSerializationContext.Global,
s.Context,
"Null constructor parameter should point to Global context");
}
public void TestTypeFieldTest()
{
var obj = new CClassWithType()
{
Type = GetType()
};
var s = new CSerializer();
var doc = s.Serialize(obj);
}
public void EnumValueAsObjectTest()
{
var obj = new CClassWithObject()
{
Obj = EDispatchMode.Threadpool
};
var s = new CSerializer();
var doc = s.Serialize(obj);
}
public bool Serialize(object _object, Type _useType, XmlElement _parentNode, CSerializer _framework)
{
var x = (CStdBaseObject)_object;
XmlExtensions.AddAttribute(_parentNode, "NAME", x.Name);
XmlExtensions.AddAttribute(_parentNode, "AGE", x.Age);
CStdBaseObject.STATUS = ETestStatus.EXTERNAL_SERIALIZER;
return(true);
}
public void TestNullableValueError()
{
int?x = null;
var s = new CSerializer();
var doc = s.Serialize(x);
Print(doc);
var d = new CDeserializer();
var y = (int)d.Deserialize(doc); // should throw the error
}
public void TestCPersonExplicitArrays()
{
var x = new CPerson();
var c = new CSerializationContext
{
FixM_ = true,
AllArraysHaveExplicitElements = true,
ArrayElementsIncludeIndicies = true
};
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(x.m_name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.m_age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
var e = (XmlElement)elem.SelectSingleNode("KidsNames");
Assert.IsNotNull(e, "Missing KidsNames element");
Assert.AreEqual("3", XmlExtensions.GetAttributeValue(e, s.Context.ArrayAttributeName), "Kids Array Count");
for (var i = 0; i < x.m_kidsNames.Length; i++)
{
Assert.AreEqual(x.m_kidsNames[i], e.ChildNodes[i].InnerText, "Kid " + i);
Assert.AreEqual(i.ToString(),
XmlExtensions.GetAttributeValue(e.ChildNodes[i], s.Context.ArrayIndexAttributeName),
"Array Index " + i);
}
e = (XmlElement)elem.SelectSingleNode("ANullValue");
Assert.IsNotNull(e, "Missing ANullValue element");
Assert.AreEqual(s.Context.NullAttributeValue,
XmlExtensions.GetAttributeValue(e, s.Context.NullAttributeName),
"Null Attribute Error");
e = (XmlElement)elem.SelectSingleNode("Address");
Assert.IsNotNull(e, "Missing Address element");
Assert.AreEqual(x.m_address.m_city, XmlExtensions.GetElementValue(e, "City"), "Address-City");
Assert.AreEqual(x.m_address.m_street, XmlExtensions.GetElementValue(e, "Street"), "Address-Street");
Assert.AreEqual(x.m_address.m_zip.ToString(), XmlExtensions.GetElementValue(e, "Zip"), "Address-Zip");
e = (XmlElement)elem.SelectSingleNode("OtherAddress");
Assert.IsNotNull(e, "Other Address Missing");
var sa = x.m_otherAddress as CSuperAddress;
Assert.AreEqual(sa.m_country, XmlExtensions.GetElementValue(e, "Country"), "OtherAddress-Country");
Assert.AreEqual(sa.m_city, XmlExtensions.GetElementValue(e, "City"), "Address-City");
Assert.AreEqual(sa.m_street, XmlExtensions.GetElementValue(e, "Street"), "Address-Street");
Assert.AreEqual(sa.m_zip.ToString(), XmlExtensions.GetElementValue(e, "Zip"), "Address-Zip");
}
/// <summary>
/// 図面情報を読み込む
/// </summary>
/// <returns></returns>
public static bool LoadFromFile(
string filename,
out string appVersion,
out string useUtility,
ref CCadObj2D editCad2D,
ref IList<CadLogic.Loop> loopList,
ref IList<EdgeCollection> edgeCollectionList,
out int incidentPortNo,
ref MediaInfo[] medias
)
{
bool success = false;
////////////////////////////////////////////////////////
// 出力データの初期化
// アプリケーションのバージョン番号
appVersion = "";
// ユーティリティ名
useUtility = "";
// 図面のクリア
editCad2D.Clear();
//// ベースループIDを初期化
//baseLoopId = 0;
// ループ情報リストの初期化
loopList.Clear();
// 入射ポートの初期化
incidentPortNo = 1;
// ポートのエッジコレクションのリストを初期化
edgeCollectionList.Clear();
// 媒質の比誘電率、比透磁率の逆数の初期化
foreach (MediaInfo media in medias)
{
// 比透磁率の逆数
media.SetP(new double[,]
{
{1.0, 0.0, 0.0},
{0.0, 1.0, 0.0},
{0.0, 0.0, 1.0}
});
// 比誘電率
media.SetQ(new double[,]
{
{1.0, 0.0, 0.0},
{0.0, 1.0, 0.0},
{0.0, 0.0, 1.0}
});
}
try
{
// Cadオブジェクトデータファイル
string basename = Path.GetDirectoryName(filename) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(filename);
string cadObjFilename = basename + Constants.CadObjExt;
if (File.Exists(cadObjFilename))
{
// Cadオブジェクトデータを外部ファイルから読み込む
using (CSerializer fin = new CSerializer(cadObjFilename, true))
{
editCad2D.Serialize(fin);
}
}
else
{
MessageBox.Show("CadObjデータファイルがありません");
return success;
}
using (StreamReader sr = new StreamReader(filename))
{
string line;
string[] tokens;
const char delimiter = ',';
int cnt = 0;
// アプリケーションのバージョン番号
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("アプリケーションのバージョン情報がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 2 || tokens[0] != "AppVersion")
{
MessageBox.Show("アプリケーションのバージョン情報がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
appVersion = tokens[1];
// ユーティリティ名
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("ユーティリティ情報がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 2 || tokens[0] != "UseUtility")
{
MessageBox.Show("ユーティリティ情報がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
useUtility = tokens[1];
if (useUtility != CadLogic.UseUtility)
{
MessageBox.Show("ユーティリティ情報が本アプリケーションのバージョンのものと一致しません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
// ベースループID
//line = sr.ReadLine();
//if (line == null)
//{
// MessageBox.Show("ベースループIDがありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
// return success;
//}
//tokens = line.Split(delimiter);
//if (tokens.Length != 2 || tokens[0] != "BaseLoopId")
//{
// MessageBox.Show("ベースループIDがありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
// return success;
//}
//baseLoopId = uint.Parse(tokens[1]);
// ループのリスト
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("ループ一覧がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 2 || tokens[0] != "LoopList")
{
MessageBox.Show("ループ一覧がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
cnt = int.Parse(tokens[1]);
for (int i = 0; i < cnt; i++)
{
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("ループ情報がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 4 || tokens[0] != "Loop")
{
MessageBox.Show("ループ情報が不正です", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
int countNo = int.Parse(tokens[1]);
uint loopId = uint.Parse(tokens[2]);
int mediaIndex = int.Parse(tokens[3]);
System.Diagnostics.Debug.Assert(countNo == i + 1);
CadLogic.Loop loop = new CadLogicBase.Loop(loopId, mediaIndex);
loopList.Add(loop);
}
// ポートのエッジコレクションのリスト
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("ポート一覧がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 2 || tokens[0] != "EdgeCollectionList")
{
MessageBox.Show("ポート一覧がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
cnt = int.Parse(tokens[1]);
for (int i = 0; i < cnt; i++)
{
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("ポート情報がありません", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length < (4 + 1) || tokens[0] != "EdgeCollection")
{
MessageBox.Show("ポート情報が不正です", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return success;
}
int countNo = int.Parse(tokens[1]);
int portNo = int.Parse(tokens[2]);
int eIdCnt = int.Parse(tokens[3]);
System.Diagnostics.Debug.Assert(countNo == i + 1);
System.Diagnostics.Debug.Assert(eIdCnt != 0 && eIdCnt == (tokens.Length - 4));
EdgeCollection edgeCollection = new EdgeCollection();
edgeCollection.No = portNo;
for (int tokenIndex = 4; tokenIndex < tokens.Length; tokenIndex++)
{
uint eId = uint.Parse(tokens[tokenIndex]);
if (!edgeCollection.ContainsEdgeId(eId))
{
bool ret = edgeCollection.AddEdgeId(eId, editCad2D);
}
}
edgeCollectionList.Add(edgeCollection);
}
// 入射ポート番号
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("入射ポート番号がありません");
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 2 || tokens[0] != "IncidentPortNo")
{
MessageBox.Show("入射ポート番号がありません");
return success;
}
incidentPortNo = int.Parse(tokens[1]);
// 媒質情報
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("媒質情報がありません");
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 2 || tokens[0] != "Medias")
{
MessageBox.Show("媒質情報がありません");
return success;
}
cnt = int.Parse(tokens[1]);
for (int i = 0; i < cnt; i++)
{
line = sr.ReadLine();
if (line == null)
{
MessageBox.Show("媒質情報が不正です");
return success;
}
tokens = line.Split(delimiter);
if (tokens.Length != 1 + 9 + 9)
{
MessageBox.Show("媒質情報が不正です");
return success;
}
int mediaIndex = int.Parse(tokens[0]);
System.Diagnostics.Debug.Assert(mediaIndex == i);
if (i >= medias.Length)
{
//読み飛ばす
continue;
}
double[,] p = new double[3, 3];
for (int m = 0; m < p.GetLength(0); m++)
{
for (int n = 0; n < p.GetLength(1); n++)
{
p[m, n] = double.Parse(tokens[1 + m * p.GetLength(1) + n]);
}
}
medias[i].SetP(p);
double[,] q = new double[3, 3];
for (int m = 0; m < q.GetLength(0); m++)
{
for (int n = 0; n < q.GetLength(1); n++)
{
q[m, n] = double.Parse(tokens[1 + 9 + m * q.GetLength(1) + n]);
}
}
medias[i].SetQ(q);
}
}
// 番号順に並び替え
((List<EdgeCollection>)edgeCollectionList).Sort();
////////////////////////////////////////////////////////////////////////
// Cadオブジェクトの色をセットする
// ループとその辺、頂点の色をセット
foreach (CadLogic.Loop loop in loopList)
{
uint id_l = loop.LoopId;
int mediaIndex = loop.MediaIndex;
MediaInfo media = medias[mediaIndex];
Color backColor = media.BackColor;
CadLogic.SetupColorOfCadObjectsForOneLoop(editCad2D, id_l, backColor);
}
// ポートの色をセットする
CadLogic.SetupColorOfPortEdgeCollection(editCad2D, edgeCollectionList, incidentPortNo);
success = true;
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + " " + exception.StackTrace);
MessageBox.Show(exception.Message);
}
return success;
}
/// <summary>
/// 編集図面をシリアライズされたバッファから読み込む
/// </summary>
/// <param name="cad2d"></param>
protected void loadEditCad2DFromSerializedBuffer(ref CCadObj2D cad2d)
{
// 図面をクリア
cad2d.Clear();
// シリアライズバッファから図面を読み込む
if (SerializedCadObjBuff != "")
{
// Cadオブジェクト一時ファイルを作成
string tmpFilename = generateTmpFilename();
createDirectory(Path.GetDirectoryName(tmpFilename));
try
{
// シリアライズバッファを一時ファイルに出力する(Shift JIS)
using (StreamWriter sw = new StreamWriter(tmpFilename, false, Encoding.GetEncoding(932)))
{
sw.Write(SerializedCadObjBuff);
}
// 一時ファイルからCadオブジェクトにデータをロードする
using (CSerializer fin = new CSerializer(tmpFilename, true)) // is_loading:true
{
cad2d.Serialize(fin);
}
// 一時ファイルを削除する
File.Delete(tmpFilename);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + " " + exception.StackTrace);
MessageBox.Show(exception.Message);
}
}
}
/// <summary>
/// 図面をシリアライズバッファに保存する
/// </summary>
protected void saveEditCad2DToSerializedBuffer(CCadObj2D cad2d)
{
// シリアライズされたCadオブジェクトのバッファを削除
clearSerializedCadObjBuffer();
// Cadオブジェクト一時ファイルを作成
string tmpFilename = generateTmpFilename();
createDirectory(Path.GetDirectoryName(tmpFilename));
try
{
// 編集Cadオブジェクトをファイルに出力する
using (CSerializer fout = new CSerializer(tmpFilename, false)) // is_loading:false
{
cad2d.Serialize(fout);
}
// シリアライズしたCadオブジェクトをメモリにロードする
using (StreamReader sr = new StreamReader(tmpFilename, Encoding.GetEncoding(932)))
{
SerializedCadObjBuff = sr.ReadToEnd();
}
// 一時ファイルを削除する
File.Delete(tmpFilename);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + " " + exception.StackTrace);
MessageBox.Show(exception.Message);
}
Console.WriteLine("SerializedCadObjBuff size = {0}", SerializedCadObjBuff.Length);
}
/// <summary>
/// 問題を設定する
/// </summary>
/// <returns></returns>
private bool setNewProblem()
{
bool success = false;
try
{
if( ProbNo == 0 )
{
CMesher2D mesh2d = null;
using(CCadObj2D cad2d = new CCadObj2D())
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0,0.0) );
pts.Add( new CVector2D(1.0,0.0) );
pts.Add( new CVector2D(1.0,0.2) );
pts.Add( new CVector2D(0.5,0.2) );
pts.Add( new CVector2D(0.5,0.8) );
pts.Add( new CVector2D(1.0,0.8) );
pts.Add( new CVector2D(1.0,1.0) );
pts.Add( new CVector2D(0.0,1.0) );
cad2d.AddPolygon( pts );
cad2d.ConnectVertex_Line(6,3);
mesh2d = new CMesher2D(cad2d,0.05);
////
using(CMesher2D msh_tmp = (CMesher2D)mesh2d.Clone())
{
mesh2d.Clear();
mesh2d.Dispose();
mesh2d = (CMesher2D)msh_tmp.Clone();
}
}
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh2d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh2d.Serialize(fin);
}
////
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
mesh2d.Clear();
mesh2d.Dispose();
}
else if( ProbNo == 1 )
{
string mshfn = "../../../input_file/hexa_tri.msh";
if (File.Exists(mshfn))
{
using(CMesher2D mesh2d = new CMesher2D())
{
mesh2d.ReadFromFile_GiDMsh(mshfn);
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh2d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh2d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
else
{
Console.WriteLine("not exist:{0}", mshfn);
MessageBox.Show(string.Format("メッシュファイル:{0}がありません", mshfn));
}
}
else if( ProbNo == 2 )
{
string mshfn = "../../../input_file/rect_quad.msh";
if (File.Exists(mshfn))
{
using(CMesher2D mesh2d = new CMesher2D())
{
mesh2d.ReadFromFile_GiDMsh(mshfn);
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh2d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh2d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
else
{
Console.WriteLine("not exist:{0}", mshfn);
MessageBox.Show(string.Format("メッシュファイル:{0}がありません", mshfn));
}
}
else if( ProbNo == 3 )
{
using(CCadObj2D cad2d = new CCadObj2D())
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0,0.0) );
pts.Add( new CVector2D(1.0,0.0) );
pts.Add( new CVector2D(1.0,0.5) );
pts.Add( new CVector2D(0.5,0.5) );
pts.Add( new CVector2D(0.5,1.0) );
pts.Add( new CVector2D(0.0,1.0) );
cad2d.AddPolygon( pts );
using(CMesher2D mesh2d = new CMesher2D(cad2d, 0.1))
using(CMesh3D_Extrude mesh3d = new CMesh3D_Extrude())
{
mesh3d.Extrude(mesh2d, 0.5, 0.1 );
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh3d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh3d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh3D(mesh3d) );
DrawerAry.InitTrans( Camera );
}
}
}
else if( ProbNo == 4 ) // load mesh of GiD
{
string mshfn = "../../../input_file/hexa_tri.msh";
if (File.Exists(mshfn))
{
using(CMesher2D mesh2d = new CMesher2D())
using(CMesh3D_Extrude mesh3d = new CMesh3D_Extrude())
{
mesh2d.ReadFromFile_GiDMsh(mshfn);
mesh3d.Extrude(mesh2d, 5.0, 0.5 );
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh3D(mesh3d) );
DrawerAry.InitTrans( Camera );
}
}
else
{
Console.WriteLine("not exist:{0}", mshfn);
MessageBox.Show(string.Format("メッシュファイル:{0}がありません", mshfn));
}
}
else if( ProbNo == 5 )
{
string mshfn = "../../../input_file/cylinder_hex.msh";
if (File.Exists(mshfn))
{
using(CMesher3D mesh3d = new CMesher3D())
{
mesh3d.ReadFromFile_GiDMsh(mshfn);
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh3d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh3d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh3D(mesh3d) );
DrawerAry.InitTrans( Camera );
}
}
else
{
Console.WriteLine("not exist:{0}", mshfn);
MessageBox.Show(string.Format("メッシュファイル:{0}がありません", mshfn));
}
}
else if( ProbNo == 6 )
{
string mshfn = "../../../input_file/cylinder_tet.msh";
if (File.Exists(mshfn))
{
using(CMesher3D mesh3d = new CMesher3D())
{
mesh3d.ReadFromFile_GiDMsh(mshfn);
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh3d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh3d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh3D(mesh3d) );
DrawerAry.InitTrans( Camera );
}
}
else
{
Console.WriteLine("not exist:{0}", mshfn);
MessageBox.Show(string.Format("メッシュファイル:{0}がありません", mshfn));
}
}
else if( ProbNo == 7 )
{
string mshfn = "../../../input_file/rect_quad.msh";
if (File.Exists(mshfn))
{
using(CMesher2D mesh2d = new CMesher2D())
using(CMesh3D_Extrude mesh3d = new CMesh3D_Extrude())
{
mesh2d.ReadFromFile_GiDMsh(mshfn);
mesh3d.Extrude(mesh2d, 5.0, 0.5 );
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh3D(mesh3d) );
DrawerAry.InitTrans( Camera );
}
}
else
{
Console.WriteLine("not exist:{0}", mshfn);
MessageBox.Show(string.Format("メッシュファイル:{0}がありません", mshfn));
}
}
else if( ProbNo == 8 )
{
using(CCadObj2D cad2d = new CCadObj2D())
{
uint id_l = 0;
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0,0.0) );
pts.Add( new CVector2D(1.0,0.0) );
pts.Add( new CVector2D(1.0,1.0) );
pts.Add( new CVector2D(0.0,1.0) );
id_l = cad2d.AddPolygon( pts ).id_l_add;
}
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.8,0.6) );
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.6,0.6) );
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.4,0.6) );
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.2,0.6) );
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.8,0.4) );
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.6,0.4) );
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.4,0.4) );
cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.2,0.4) );
using(CMesher2D mesh2d = new CMesher2D(cad2d, 0.02))
{
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh2d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh2d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
}
else if( ProbNo == 9 )
{
using(CCadObj2D cad2d = new CCadObj2D())
{
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0,0.0) );
pts.Add( new CVector2D(1.0,0.0) );
pts.Add( new CVector2D(1.0,1.0) );
pts.Add( new CVector2D(0.0,1.0) );
cad2d.AddPolygon( pts );
}
cad2d.SetCurve_Arc(1,true, -0.5);
cad2d.SetCurve_Arc(2,false,-0.5);
cad2d.SetCurve_Arc(3,true, -0.5);
cad2d.SetCurve_Arc(4,false,-0.5);
using(CMesher2D mesh2d = new CMesher2D(cad2d, 0.05))
{
using(CSerializer fout = new CSerializer("hoge.txt", false))
{
// write file
mesh2d.Serialize(fout);
}
using(CSerializer fin = new CSerializer("hoge.txt", true))
{ // load file
mesh2d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
}
else if( ProbNo == 10 )
{
using(CCadObj2D cad2d = new CCadObj2D())
{
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0,0.0) );
pts.Add( new CVector2D(1.0,0.0) );
pts.Add( new CVector2D(1.0,1.0) );
pts.Add( new CVector2D(0.0,1.0) );
uint id_l = cad2d.AddPolygon( pts ).id_l_add;
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.3,0.2)).id_v_add;
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.7,0.2)).id_v_add;
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.7,0.8)).id_v_add;
uint id_v4 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l, new CVector2D(0.3,0.8)).id_v_add;
cad2d.ConnectVertex_Line(id_v1,id_v2);
cad2d.ConnectVertex_Line(id_v2,id_v3);
cad2d.ConnectVertex_Line(id_v3,id_v4);
cad2d.ConnectVertex_Line(id_v4,id_v1);
}
using(CMesher2D mesh2d = new CMesher2D())
{
mesh2d.AddIdLCad_CutMesh(1); // cut mesh to loop whitch have id 1
mesh2d.SetMeshingMode_ElemLength(0.05);
mesh2d.Meshing(cad2d);
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
}
else if( ProbNo == 11 ) // mesh with cut
{
using(CCadObj2D cad2d = new CCadObj2D())
{
uint id_l;
uint id_e1, id_e2, id_e3, id_e4, id_e5;
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0,0.0) );
pts.Add( new CVector2D(0.3,0.0) );
pts.Add( new CVector2D(1.0,0.0) );
pts.Add( new CVector2D(1.0,1.0) );
pts.Add( new CVector2D(0.0,1.0) );
id_l = cad2d.AddPolygon( pts ).id_l_add;
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l, new CVector2D(0.3,0.5) ).id_v_add;
id_e1 = cad2d.ConnectVertex_Line(2,id_v1).id_e_add;
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l, new CVector2D(0.7,0.5) ).id_v_add;
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l, new CVector2D(0.7,0.2) ).id_v_add;
uint id_v4 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l, new CVector2D(0.7,0.8) ).id_v_add;
uint id_v5 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l, new CVector2D(0.5,0.5) ).id_v_add;
uint id_v6 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l, new CVector2D(0.9,0.5) ).id_v_add;
id_e2 = cad2d.ConnectVertex_Line(id_v2,id_v3).id_e_add;
id_e3 = cad2d.ConnectVertex_Line(id_v2,id_v4).id_e_add;
id_e4 = cad2d.ConnectVertex_Line(id_v2,id_v5).id_e_add;
id_e5 = cad2d.ConnectVertex_Line(id_v2,id_v6).id_e_add;
}
using(CMesher2D mesh2d = new CMesher2D(cad2d, 0.2))
{
IList<uint> aIdMsh_Inc = new List<uint>();
aIdMsh_Inc.Add( mesh2d.GetElemID_FromCadID(id_l,CAD_ELEM_TYPE.LOOP) );
IList<uint> aIdMshBar_Cut = new List<uint>();
aIdMshBar_Cut.Add( mesh2d.GetElemID_FromCadID(id_e1,CAD_ELEM_TYPE.EDGE) );
aIdMshBar_Cut.Add( mesh2d.GetElemID_FromCadID(id_e2,CAD_ELEM_TYPE.EDGE) );
aIdMshBar_Cut.Add( mesh2d.GetElemID_FromCadID(id_e3,CAD_ELEM_TYPE.EDGE) );
aIdMshBar_Cut.Add( mesh2d.GetElemID_FromCadID(id_e4,CAD_ELEM_TYPE.EDGE) );
aIdMshBar_Cut.Add( mesh2d.GetElemID_FromCadID(id_e5,CAD_ELEM_TYPE.EDGE) );
////////////////
IList< IList<int> > aLnods = new List<IList<int>>();
IList<uint> mapVal2Co = new List<uint>();
mesh2d.GetClipedMesh(out aLnods, out mapVal2Co, aIdMsh_Inc, aIdMshBar_Cut);
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
}
else if( ProbNo == 12 ) // mesh with cut
{
using(CCadObj2D cad2d = new CCadObj2D())
{
uint id_l1, id_l2;
uint id_e3, id_e4;
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0, 0.0) );
pts.Add( new CVector2D(1.0, 0.0) );
pts.Add( new CVector2D(1.5, 0.0) );
pts.Add( new CVector2D(2.0, 0.0) );
pts.Add( new CVector2D(2.0, 1.0) );
pts.Add( new CVector2D(1.5, 1.0) );
pts.Add( new CVector2D(1.0, 1.0) );
pts.Add( new CVector2D(0.0, 1.0) );
uint id_l0 = cad2d.AddPolygon( pts ).id_l_add;
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l0, new CVector2D(0.5,0.5) ).id_v_add;
uint id_e1 = cad2d.ConnectVertex_Line(2,7).id_e_add;
uint id_e2 = cad2d.ConnectVertex_Line(3,6).id_e_add;
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE,id_e1, new CVector2D(1.0,0.5) ).id_v_add;
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE,1, new CVector2D(0.5,0.0) ).id_v_add;
id_e3 = cad2d.ConnectVertex_Line(id_v1,id_v2).id_e_add;
id_e4 = cad2d.ConnectVertex_Line(id_v1,id_v3).id_e_add;
id_l1 = 1;
id_l2 = 2;
}
using(CMesher2D mesh2d = new CMesher2D(cad2d, 0.2))
{
IList<uint> aIdMsh_Inc = new List<uint>();
aIdMsh_Inc.Add( mesh2d.GetElemID_FromCadID(id_l1,CAD_ELEM_TYPE.LOOP) );
aIdMsh_Inc.Add( mesh2d.GetElemID_FromCadID(id_l2,CAD_ELEM_TYPE.LOOP) );
IList<uint> aIdMshBar_Cut = new List<uint>();
//aIdMshBar_Cut.Add( mesh2d.GetElemID_FromCadID(id_e3,CAD_ELEM_TYPE.EDGE) );
aIdMshBar_Cut.Add( mesh2d.GetElemID_FromCadID(id_e4,CAD_ELEM_TYPE.EDGE) );
////////////////
IList< IList<int> > aLnods = new List<IList<int>>();
IList<uint> mapVal2Co = new List<uint>();
mesh2d.GetClipedMesh(out aLnods, out mapVal2Co, aIdMsh_Inc, aIdMshBar_Cut);
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
}
else if( ProbNo == 13 )
{
using(CCadObj2D cad2d = new CCadObj2D())
{
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add( new CVector2D(0.0, 0.0) ); // 1
pts.Add( new CVector2D(1.5, 0.0) ); // 2
pts.Add( new CVector2D(1.5, 0.4) ); // 3
pts.Add( new CVector2D(1.0, 0.4) ); // 4
pts.Add( new CVector2D(1.0, 0.5) ); // 5
pts.Add( new CVector2D(2.0, 0.5) ); // 6
pts.Add( new CVector2D(2.0, 1.0) ); // 7
pts.Add( new CVector2D(0.0, 1.0) ); // 8
pts.Add( new CVector2D(0.0, 0.5) ); // 9
uint id_l0 = cad2d.AddPolygon( pts ).id_l_add;
uint id_e1 = cad2d.ConnectVertex_Line(5,9).id_e_add;
cad2d.ShiftLayer_Loop(id_l0,true);
double[] col = new double[3] { 0.9, 0.4, 0.4 };
cad2d.SetColor_Loop(id_l0, col);
cad2d.AddVertex(CAD_ELEM_TYPE.EDGE,3, new CVector2D(1.3,0.5));
}
using(CMesher2D mesh2d = new CMesher2D(cad2d, 0.05))
{
DrawerAry.Clear();
DrawerAry.PushBack( new CDrawerMsh2D(mesh2d) );
DrawerAry.InitTrans( Camera );
}
}
}
else if( ProbNo == 14 )
{
string svgfn = "../../../input_file/shape2d_0.svg";
if (File.Exists(svgfn))
{
CCadObj2D cad2d = null;
CCadSVG.ReadSVG_AddLoopCad(svgfn, out cad2d);
using (CMesher2D mesh2d = new CMesher2D())
{
mesh2d.SetMeshingMode_ElemSize(400);
mesh2d.AddIdLCad_CutMesh(1);
mesh2d.Meshing(cad2d);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawerMsh2D(mesh2d));
DrawerAry.InitTrans(Camera);
}
cad2d.Clear();
cad2d.Dispose();
}
else
{
Console.WriteLine("not exist:{0}", svgfn);
MessageBox.Show(string.Format("SVGファイル:{0}がありません", svgfn));
}
}
success = true;
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + " " + exception.StackTrace);
}
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
DrawerGlUtility.SetProjectionTransform(Camera);
Glut.glutPostRedisplay();
ProbNo++;
if (ProbNo == ProbCnt) ProbNo = 0;
return success;
}
public void TestConstructorWithNominalTypeAndObjectAndSerializerAndIsUpdateDocument()
{
var c = CreateC();
var serializer = new CSerializer();
var serializationOptions = DocumentSerializationOptions.SerializeIdFirstInstance;
var wrapper = new BsonDocumentWrapper(typeof(C), c, serializer, serializationOptions, true);
Assert.AreEqual(true, wrapper.IsUpdateDocument);
Assert.AreEqual(serializationOptions, wrapper.SerializationOptions);
Assert.AreSame(serializer, wrapper.Serializer);
Assert.AreSame(typeof(C), wrapper.WrappedNominalType);
Assert.AreSame(c, wrapper.WrappedObject);
Assert.AreEqual(false, wrapper.IsMaterialized);
wrapper = new BsonDocumentWrapper(typeof(C), null, serializer, serializationOptions, true);
Assert.AreEqual(true, wrapper.IsUpdateDocument);
Assert.AreEqual(serializationOptions, wrapper.SerializationOptions);
Assert.AreSame(serializer, wrapper.Serializer);
Assert.AreSame(typeof(C), wrapper.WrappedNominalType);
Assert.AreSame(null, wrapper.WrappedObject);
Assert.AreEqual(false, wrapper.IsMaterialized);
Assert.Throws<ArgumentNullException>(() => new BsonDocumentWrapper(null, c, serializer, serializationOptions, true));
Assert.Throws<ArgumentNullException>(() => new BsonDocumentWrapper(typeof(C), c, null, serializationOptions, true));
Assert.DoesNotThrow(() => new BsonDocumentWrapper(typeof(C), c, serializer, null, true));
}
/////////////////////////////////////////////////////////////////////////////
// 定数
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// 型
/////////////////////////////////////////////////////////////////////////////
/// <summary>
/// 図面情報を保存する
/// </summary>
/// <param name="filename"></param>
/// <param name="editCad2D"></param>
/// <param name="loopList"></param>
/// <param name="edgeCollectionList"></param>
/// <param name="incidentPortNo"></param>
/// <param name="medias"></param>
public static void SaveToFile(
string filename,
CCadObj2D editCad2D,
IList<CadLogic.Loop> loopList,
IList<EdgeCollection> edgeCollectionList,
int incidentPortNo,
MediaInfo[] medias
)
{
// 番号順に並び替え
((List<EdgeCollection>)edgeCollectionList).Sort();
try
{
// Cadオブジェクトデータファイル
string basename = Path.GetDirectoryName(filename) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(filename);
string cadObjFilename = basename + Constants.CadObjExt;
// Cadオブジェクトデータを外部ファイルに書き込み
using (CSerializer fout = new CSerializer(cadObjFilename, false))
{
editCad2D.Serialize(fout);
}
// Cadデータの書き込み
using (StreamWriter sw = new StreamWriter(filename))
{
int counter;
string line;
// アプリケーションのバージョン番号
sw.WriteLine("AppVersion,{0}", MyUtilLib.MyUtil.getAppVersion());
// CadLogicの使用ユーティリティ名
sw.WriteLine("UseUtility,{0}", CadLogic.UseUtility);
//// ベースループID
//sw.WriteLine("BaseLoopId,{0}", baseLoopId);
// ループのリスト
counter = 0;
sw.WriteLine("LoopList,{0}", loopList.Count);
foreach (CadLogic.Loop loop in loopList)
{
sw.WriteLine("Loop,{0},{1},{2}", ++counter, loop.LoopId, loop.MediaIndex);
}
// ポートのエッジコレクションのリスト
counter = 0;
sw.WriteLine("EdgeCollectionList,{0}", edgeCollectionList.Count);
foreach (EdgeCollection edgeCollection in edgeCollectionList)
{
line = string.Format("EdgeCollection,{0},{1},{2},", ++counter, edgeCollection.No, edgeCollection.EdgeIds.Count);
foreach (uint eId in edgeCollection.EdgeIds)
{
line += string.Format("{0},", eId);
}
line = line.Remove(line.Length - 1); // 最後の,を削除
sw.WriteLine(line);
}
// 入射ポート番号
sw.WriteLine("IncidentPortNo,{0}", incidentPortNo);
// 媒質情報の個数
sw.WriteLine("Medias,{0}", medias.Length);
// 媒質情報の書き込み
for (int i = 0; i < medias.Length; i++)
{
MediaInfo media = medias[i];
line = string.Format("{0},", i);
double[,] p = media.P;
for (int m = 0; m < p.GetLength(0); m++)
{
for (int n = 0; n < p.GetLength(1); n++)
{
line += string.Format("{0},", p[m, n]);
}
}
double[,] q = media.Q;
for (int m = 0; m < q.GetLength(0); m++)
{
for (int n = 0; n < q.GetLength(1); n++)
{
line += string.Format("{0},", q[m, n]);
}
}
line = line.Remove(line.Length - 1); // 最後の,を削除
sw.WriteLine(line);
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + " " + exception.StackTrace);
MessageBox.Show(exception.Message);
}
}
/// <summary>
/// 問題を設定する
/// </summary>
/// <returns></returns>
private bool setNewProblem()
{
bool success = false;
try
{
using (CCadObj2D cad2d = new CCadObj2D())
{
if (ProbNo == 0)
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(0.0, 1.0));
uint id_l0 = cad2d.AddPolygon(pts, 0).id_l_add;
uint id_v5 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.5, 0.5)).id_v_add;
uint id_v6 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.5, 0.8)).id_v_add;
uint id_v7 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.8, 0.5)).id_v_add;
uint id_v8 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.5, 0.2)).id_v_add;
uint id_v9 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.2, 0.5)).id_v_add;
cad2d.ConnectVertex_Line(id_v5, id_v6);
cad2d.ConnectVertex_Line(id_v5, id_v7);
cad2d.ConnectVertex_Line(id_v5, id_v8);
cad2d.ConnectVertex_Line(id_v5, id_v9);
using (CCadObj2D cad2dtmp = cad2d.Clone()) // コピーのテスト
{
// export to the file
using (CSerializer fout = new CSerializer("hoge.txt", false))
{
cad2dtmp.Serialize(fout);
}
}
// import form the file
cad2d.Clear();
using (CSerializer fin = new CSerializer("hoge.txt", true))
{
cad2d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 1)
{
CCadObj2D.CResAddPolygon res;
{ // define shape
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(2.0, 1.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(1.0, 2.0));
pts.Add(new CVector2D(0.0, 2.0));
res = cad2d.AddPolygon(pts);
}
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, res.aIdE[1]);
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, res.aIdE[2]);
cad2d.RemoveElement(CAD_ELEM_TYPE.VERTEX, res.aIdV[2]);
uint id_e_new = cad2d.ConnectVertex_Line(res.aIdE[3], res.aIdE[1]).id_e_add;
CCadObj2D.CResAddVertex res0 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, id_e_new, new CVector2D(1, 0.4));
CCadObj2D.CResAddVertex res1 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, id_e_new, new CVector2D(1, 0.6));
CCadObj2D.CResAddVertex res2 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, res.aIdE[5], new CVector2D(0, 0.4));
CCadObj2D.CResAddVertex res3 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, res.aIdE[5], new CVector2D(0, 0.6));
cad2d.ConnectVertex_Line(res0.id_v_add, res2.id_v_add);
cad2d.ConnectVertex_Line(res1.id_v_add, res3.id_v_add);
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, res1.id_e_add);
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, res3.id_e_add);
using (CCadObj2D cad2dtmp = cad2d.Clone()) // コピーのテスト
{
// export to the file
using (CSerializer fout = new CSerializer("hoge.txt", false))
{
cad2dtmp.Serialize(fout);
}
}
// import form the file
cad2d.Clear();
using (CSerializer fin = new CSerializer("hoge.txt", true))
{
cad2d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 2)
{
uint id_l0;
{ // Make model
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 0.4));
pts.Add(new CVector2D(0.0, 0.4));
id_l0 = cad2d.AddPolygon(pts).id_l_add;
}
//cad2d.SetCurve_Arc(1,true,-0.2);
//cad2d.SetCurve_Arc(2,true, -0.5);
cad2d.SetCurve_Arc(3, false, 0);
//cad2d.SetCurve_Arc(4,true, -0.5);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 3)
{
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.NOT_SET, 0, new CVector2D(0, 0)).id_v_add;
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.NOT_SET, 0, new CVector2D(1, 0)).id_v_add;
cad2d.ConnectVertex_Line(id_v1, id_v2);
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.NOT_SET, 0, new CVector2D(1, 1)).id_v_add;
cad2d.ConnectVertex_Line(id_v2, id_v3);
uint id_v4 = cad2d.AddVertex(CAD_ELEM_TYPE.NOT_SET, 0, new CVector2D(0, 1)).id_v_add;
cad2d.ConnectVertex_Line(id_v4, id_v3);
uint id_v5 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, 2, new CVector2D(1, 0.5)).id_v_add;
uint id_v7 = cad2d.AddVertex(CAD_ELEM_TYPE.NOT_SET, 0, new CVector2D(0.5, 0.5)).id_v_add;
cad2d.ConnectVertex_Line(id_v5, id_v7);
uint id_v6 = cad2d.AddVertex(CAD_ELEM_TYPE.NOT_SET, 0, new CVector2D(1.5, 0.5)).id_v_add;
cad2d.ConnectVertex_Line(id_v5, id_v6);
cad2d.ConnectVertex_Line(id_v4, id_v1);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 4)
{
uint id_l0;
{ // define shape
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(0.0, 1.0));
id_l0 = cad2d.AddPolygon(pts).id_l_add;
}
//uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP,id_l0,new CVector2D(0.5,0.5));
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.5, 0.2)).id_v_add;
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.8, 0.5)).id_v_add;
uint id_v4 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.5, 0.8)).id_v_add;
uint id_v5 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.2, 0.5)).id_v_add;
cad2d.ConnectVertex_Line(id_v2, id_v3);
cad2d.ConnectVertex_Line(id_v3, id_v4);
cad2d.ConnectVertex_Line(id_v4, id_v5);
uint id_e1 = cad2d.ConnectVertex_Line(id_v5, id_v2).id_e_add;
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, id_e1);
cad2d.ConnectVertex_Line(id_v5, id_v2);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 5)
{
uint id_l0;
{ // define shape
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(0.0, 1.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(1.0, 0.0));
id_l0 = cad2d.AddPolygon(pts).id_l_add;
}
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 6)
{
uint id_l0;
{ // define initial loop
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(0.0, 1.0));
id_l0 = cad2d.AddPolygon(pts).id_l_add;
}
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.3, 0.1));
pts.Add(new CVector2D(0.9, 0.1));
pts.Add(new CVector2D(0.9, 0.7));
cad2d.AddPolygon(pts, id_l0);
}
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.1, 0.9));
pts.Add(new CVector2D(0.7, 0.9));
pts.Add(new CVector2D(0.1, 0.3));
cad2d.AddPolygon(pts, id_l0);
}
uint id_e0 = cad2d.ConnectVertex_Line(1, 3).id_e_add;
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, id_e0);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 7)
{
uint id_l0;
{ // define shape
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(0.0, 1.0));
id_l0 = cad2d.AddPolygon(pts).id_l_add;
}
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.9, 0.7)).id_v_add;
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.9, 0.1)).id_v_add;
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.3, 0.1)).id_v_add;
cad2d.ConnectVertex_Line(id_v1, id_v2);
cad2d.ConnectVertex_Line(id_v2, id_v3);
cad2d.ConnectVertex_Line(id_v3, id_v1);
{
uint id_e0 = cad2d.ConnectVertex_Line(id_v2, 2).id_e_add;
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, id_e0);
}
{
uint id_e0 = cad2d.ConnectVertex_Line(2, id_v2).id_e_add;
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, id_e0);
}
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 8)
{
uint id_e3, id_e4;
{
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0)); // 1
pts.Add(new CVector2D(1.0, 0.0)); // 2
pts.Add(new CVector2D(1.5, 0.0)); // 3
pts.Add(new CVector2D(2.0, 0.0)); // 4
pts.Add(new CVector2D(2.0, 1.0)); // 5
pts.Add(new CVector2D(1.5, 1.0)); // 6
pts.Add(new CVector2D(1.0, 1.0)); // 7
pts.Add(new CVector2D(0.0, 1.0)); // 8
uint id_l0 = cad2d.AddPolygon(pts).id_l_add;
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.5, 0.5)).id_v_add;
uint id_e1 = cad2d.ConnectVertex_Line(2, 7).id_e_add;
uint id_e2 = cad2d.ConnectVertex_Line(3, 6).id_e_add;
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, id_e1, new CVector2D(1.0, 0.5)).id_v_add;
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, 1, new CVector2D(0.5, 0.0)).id_v_add;
id_e3 = cad2d.ConnectVertex_Line(id_v1, id_v2).id_e_add;
id_e4 = cad2d.ConnectVertex_Line(id_v1, id_v3).id_e_add;
}
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 9)
{
uint id_l0;
{ // define shape
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(0.0, 1.0));
id_l0 = cad2d.AddPolygon(pts).id_l_add;
}
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.2, 0.7)).id_v_add;
uint id_v2 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.2, 0.3)).id_v_add;
uint id_e0 = cad2d.ConnectVertex_Line(id_v1, id_v2).id_e_add;
uint id_v3 = cad2d.AddVertex(CAD_ELEM_TYPE.EDGE, id_e0, new CVector2D(0.2, 0.5)).id_v_add;
uint id_v4 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.5, 0.5)).id_v_add;
uint id_v5 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, id_l0, new CVector2D(0.7, 0.5)).id_v_add;
uint id_e1 = cad2d.ConnectVertex_Line(id_v3, id_v4).id_e_add;
uint id_e2 = cad2d.ConnectVertex_Line(id_v4, id_v5).id_e_add;
cad2d.RemoveElement(CAD_ELEM_TYPE.EDGE, id_e1);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 10)
{
uint id_l0;
{ // define shape
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(0.0, 1.0));
id_l0 = cad2d.AddPolygon(pts).id_l_add;
}
uint id_v1 = cad2d.AddVertex(CAD_ELEM_TYPE.LOOP, 0, new CVector2D(1.1, 0)).id_v_add;
cad2d.RemoveElement(CAD_ELEM_TYPE.VERTEX, id_v1);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 11)
{
{ // define initial loop
IList<CVector2D> pts = new List<CVector2D>();
pts.Add(new CVector2D(0.0, 0.0));
pts.Add(new CVector2D(1.0, 0.0));
pts.Add(new CVector2D(1.0, 1.0));
pts.Add(new CVector2D(0.0, 1.0));
pts.Add(new CVector2D(0.0, 0.5));
cad2d.AddPolygon(pts);
}
/*
{
IList<CVector2D> aRelCo = new List<CVector2D>();
aRelCo.Add(new CVector2D(0.25, -0.1));
aRelCo.Add(new CVector2D(0.5, -0.0));
aRelCo.Add(new CVector2D(0.75, -0.1));
cad2d.SetCurve_Polyline(1, aRelCo);
}
cad2d.SetCurve_Arc(2, true, -1);
{
IList<CVector2D> aRelCo = new List<CVector2D>();
aRelCo.Add(new CVector2D(+0.01, 0.35));
aRelCo.Add(new CVector2D(-0.05, 0.25));
aRelCo.Add(new CVector2D(+0.01, 0.15));
cad2d.SetCurve_Polyline(5, aRelCo);
}
*/
cad2d.RemoveElement(CAD_ELEM_TYPE.VERTEX, 1); // removing this point marges 2 polylines
cad2d.SetCurve_Bezier(3, 0.2, +0.5, 0.8, -0.5);
//cad2d.SetCurve_Bezier(4, 0.0,-1.0, 0.3,+1.0);
//cad2d.SetCurve_Bezier(5, 0.0,-1.0, 0.3,-1.0);
Console.WriteLine("area : {0}", cad2d.GetArea_Loop(1));
cad2d.WriteToFile_dxf("hoge.dxf", 1);
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else if (ProbNo == 12)
{
string svgfname = "../../../input_file/shape2d_0.svg";
CCadObj2D cad2dtmp = null;
if (File.Exists(svgfname))
{
DelFEM4NetCad.CCadSVG.ReadSVG_AddLoopCad(svgfname, out cad2dtmp);
// export to the file
using (CSerializer fout = new CSerializer("hoge.txt", false))
{
cad2dtmp.Serialize(fout);
}
cad2dtmp.Dispose();
// import form the file
cad2d.Clear();
using (CSerializer fin = new CSerializer("hoge.txt", true))
{
cad2d.Serialize(fin);
}
DrawerAry.Clear();
DrawerAry.PushBack(new CDrawer_Cad2D(cad2d));
DrawerAry.InitTrans(Camera);
}
else
{
MessageBox.Show("SVGファイルがありません");
}
}
} // using cad2d
success = true;
}
catch (Exception exception)
{
Console.WriteLine(exception.Message + " " + exception.StackTrace);
}
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
DrawerGlUtility.SetProjectionTransform(Camera);
Glut.glutPostRedisplay();
ProbNo++;
if (ProbNo == ProbCnt) ProbNo = 0;
return success;
}
