public MainForm()
{
InitializeComponent();
p = new Perspective(this);
testSphere = new Sphere (new Point3(100, 100, 0), 100, Color.Yellow);
testSphere2 = new Sphere (new Point3 (250, 250, 0), 50, Color.Blue);
testSphere3 = new Sphere (new Point3 (250, 250, 0), 10, Color.Wheat);
}
// GET: Perspectives/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Perspective perspective = db.Perspectives.Find(id);
if (perspective == null)
{
return(HttpNotFound());
}
ViewBag.IdFramework = new SelectList(db.Frameworks, "IdFramework", "Name", perspective.IdFramework);
return(View(perspective));
}
// <summary>
// Creates new instance of <see cref="SemanticResolver" />.
// </summary>
internal static SemanticResolver Create(
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters,
IEnumerable <DbVariableReferenceExpression> variables)
{
DebugCheck.NotNull(perspective);
DebugCheck.NotNull(parserOptions);
return(new SemanticResolver(
parserOptions,
ProcessParameters(parameters, parserOptions),
ProcessVariables(variables, parserOptions),
new TypeResolver(perspective, parserOptions)));
}
protected override void SetInPerspective(Perspective perspective, bool included)
{
// Including/excluding a table from a perspective, is equivalent to including/excluding all child
// objects. The PerspectiveTable will be created automatically if needed.
Table.Measures.InPerspective(perspective, included);
Table.Hierarchies.InPerspective(perspective, included);
Table.Columns.InPerspective(perspective, included);
var pts = perspective.MetadataObject.PerspectiveTables;
if (!included && pts.Contains(Table.Name))
{
pts.Remove(Table.Name);
}
}
public void StartPerspective_OVERRIDE_Test1()
{
_logger.Info("{}の実行を開始します", nameof(StartPerspective_BWAB_Test2));
string PERSPECTIVE_NAME1 = "TestPerspective1";
string PERSPECTIVE_NAME2 = "TestPerspective2";
List <IContentBuilder> contentBuilders = new List <IContentBuilder>();
contentBuilders.Add(BuildContentBuilder("MyContent1a"));
contentBuilders.Add(BuildContentBuilder("MyContent1b"));
contentBuilders.Add(BuildContentBuilder("MyContent2"));
// テスト対象の生成と設定
var manager = new HarmonicManager();
manager.Verify(contentBuilders);
var dict = new Dictionary <string, string>();
dict.Add("MyFrameA", "MyContent1a"); // 重複するフレームにコンテントを配置
dict.Add("MyFrameB", "MyContent1b"); // 重複しないフレームにコンテントを配置
var perspective = new Perspective(PERSPECTIVE_NAME1, ArbitrationMode.AWAB, dict, manager);
manager.RegisterPerspective(perspective);
var dict2 = new Dictionary <string, string>();
dict2.Add("MyFrameA", "MyContent2"); // 重複するフレームにコンテントを配置
var perspective2 = new Perspective(PERSPECTIVE_NAME2, ArbitrationMode.OVERRIDE, dict2, manager);
manager.RegisterPerspective(perspective2);
manager.StartPerspective(PERSPECTIVE_NAME1);
// テスト対象のロジック呼び出し
manager.StartPerspective(PERSPECTIVE_NAME2);
// TODO: ここに、テストコードを実装する
var stack_MyFrameA = manager._FrameList.GetContentStack("MyFrameA");
Assert.Single(stack_MyFrameA);
Assert.Equal(stack_MyFrameA.ToArray()[0].Name, "MyContent2");
Assert.Equal(stack_MyFrameA.ToArray()[0].Status, ContentStatus.Run);
var stack_MyFrameB = manager._FrameList.GetContentStack("MyFrameB");
Assert.Equal(0, stack_MyFrameB.Count);
}
private void RotateClockwise()
{
previousGreenRotation = GreenRotation;
prevoiusBlueRotation = BlueRotation;
if (Side != Perspective.Right)
{
Side++;
}
else
{
Side = Perspective.Front;
}
StartRotating();
}
/// <summary>
/// Add Maya like camera handling for orbiting camera.
/// </summary>
/// <param name="window">window that receives input system events</param>
/// <param name="projection">Projection transformation.</param>
/// <param name="orbit">Orbit transformation.</param>
public static void AddMayaCameraEvents(this INativeWindow window, Perspective projection, Orbit orbit)
{
window.MouseMove += (s, e) =>
{
if (ButtonState.Pressed == e.Mouse.LeftButton)
{
orbit.Azimuth += 300 * e.XDelta / (float)window.Width;
orbit.Elevation += 300 * e.YDelta / (float)window.Height;
}
};
window.MouseWheel += (s, e) =>
{
orbit.Distance *= (float)Math.Pow(1.05, e.DeltaPrecise);
orbit.Distance = Geometry.MathHelper.Clamp(orbit.Distance, projection.NearClip, projection.FarClip);
};
}
void OnTriggerExit(Collider other)
{
if (other.tag == "PressurePlate")
{
this.transform.parent = null;
}
if ((other.tag == "MovingPlatform" || other.tag == "PerspectiveBlock") && blockGravity.contact == false)
{
if (camera.turning == false)
{
currentPlatform = null;
Parent = null;
}
}
}
void OnTriggerEnter(Collider other)
{
if (other.tag == "PressurePlate")
{
this.transform.parent = other.transform;
}
if (other.tag == "MovingPlatform" || other.tag == "PerspectiveBlock")
{
if (camera.turning == false)
{
currentPlatform = other.transform.gameObject.GetComponent <Perspective>();
Parent = other.gameObject.transform;
}
}
}
public void WriteTo(XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("ThreeDProperties");
{
if (Enabled.HasValue)
{
xmlWriter.WriteElementString("Enabled", Enabled.Value.ToString());
}
xmlWriter.WriteElementString("ProjectionMode", ProjectionMode.ToString());
if (ProjectionMode == ProjectionMode3DForRendering.Perspective)
{
if (Perspective.HasValue)
{
xmlWriter.WriteElementString("Perspective", Perspective.ToString());
}
}
if (Rotation.HasValue)
{
xmlWriter.WriteElementString("Rotation", Rotation.ToString());
}
if (Inclination.HasValue)
{
xmlWriter.WriteElementString("Inclination", Inclination.ToString());
}
xmlWriter.WriteElementString("Shading", Shading.ToString());
if (WallThickness.HasValue)
{
xmlWriter.WriteElementString("WallThickness", WallThickness.ToString());
}
//if ( chart type is bar OR column)
{
xmlWriter.WriteElementString("DrawingStyle", DrawingStyle.ToString());
if (Clustered.HasValue)
{
xmlWriter.WriteElementString("Clustered", Clustered.ToString());
}
}
}
xmlWriter.WriteEndElement();
}
public ArrayGrid(Perspective perspective, T[,] grid, Vector2 tileSize, bool wrapAround = false,
bool isScreenGrid = false)
{
Position = Vector2.Zero;
Cells = grid;
Width = grid.GetLength(0);
Height = grid.GetLength(1);
TileSize = tileSize;
DrawLayer = 0; //temp
Perspective = perspective;
WrapAround = wrapAround;
IsScreenGrid = isScreenGrid;
}
public static Perspective DeserializePerspective(JObject json, Model model)
{
var tom = TOM.JsonSerializer.DeserializeObject <TOM.Perspective>(json.ToString(Formatting.None));
tom.Name = model.Perspectives.GetNewName(tom.Name);
var tomModel = model.MetadataObject;
foreach (var pt in tom.PerspectiveTables.ToList())
{
if (tomModel.Tables.Contains(pt.Name))
{
var tomTable = tomModel.Tables[pt.Name];
foreach (var pc in pt.PerspectiveColumns.ToList())
{
if (!tomTable.Columns.Contains(pc.Name))
{
pt.PerspectiveColumns.Remove(pc.Name);
}
}
foreach (var pm in pt.PerspectiveMeasures.ToList())
{
if (!tomTable.Measures.Contains(pm.Name))
{
pt.PerspectiveMeasures.Remove(pm.Name);
}
}
foreach (var ph in pt.PerspectiveHierarchies.ToList())
{
if (!tomTable.Hierarchies.Contains(ph.Name))
{
pt.PerspectiveHierarchies.Remove(ph.Name);
}
}
}
else
{
tom.PerspectiveTables.Remove(pt.Name);
}
}
var perspective = Perspective.CreateFromMetadata(model, tom);
return(perspective);
}
void OnTriggerEnter(Collider other)
{
if (other.tag == "Coin")
{
GM.instance.CoinSound();
Destroy(other.gameObject);
GM.instance.IncrementCoins();
}
if (other.tag == "PressurePlate")
{
onRotatingPlatform = true;
this.transform.parent = other.transform;
//Try and implement a "STICK" functionality
//other.gameObject.GetComponent<RotatePlatform> ().Rotate();
}
if (other.tag == "GravityShift")
{
if (camera.turning == false)
{
this.GetComponent <GravityNew> ().gravityShift = !this.GetComponent <GravityNew> ().gravityShift;
}
else
{
//this.GetComponent<GravityNew> ().gravityShift = false;
}
}
if (other.tag == "MovingPlatform" || other.tag == "PerspectiveBlock")
{
//this.transform.parent = other.gameObject.transform;
//fakeChild.transform.position = other.gameObject.transform.position;
if (camera.turning == false)
{
currentPlatform = other.transform.gameObject.GetComponent <Perspective>();
this.GetComponent <GravityNew> ().currentPlatform = currentPlatform;
Parent = other.gameObject.transform;
}
}
if (other.tag == "death")
{
GM.instance.DeathReset();
}
}
public void Write_OneElementAtEachStep_FileIsCorrectlyBuilt()
{
var header = GetHeader();
var expectedContent = header + "\"p\";\"mg\";\"m1\";\"[m1]\";\"d\";\"[d]\";\"h1\";\"[h1]\";\"l1\";\"[l1]\";\"0\";\"p1\";\"[p1]\"\r\n";
var expectedFilename = Path.Combine(DiskOnFile.GetDirectoryPath(), "ExpectedCSV-" + MethodBase.GetCurrentMethod() + ".csv");
if (File.Exists(expectedFilename))
{
File.Delete(expectedFilename);
}
File.AppendAllText(expectedFilename, expectedContent, Encoding.UTF8);
var filename = Path.Combine(DiskOnFile.GetDirectoryPath(), @"ActualCSV-" + MethodBase.GetCurrentMethod() + ".csv");
var metadata = new CubeMetadata();
var p = new Perspective("p");
metadata.Perspectives.Add(p);
var mg = new MeasureGroup("mg");
p.MeasureGroups.Add(mg);
var m1 = new Measure("[m1]", "m1", "df");
mg.Measures.Add(m1);
var d = new Dimension("[d]", "d");
mg.LinkedDimensions.Add(d);
var h1 = new Hierarchy("[h1]", "h1", "df");
d.Hierarchies.Add(h1);
var l1 = new Level("[l1]", "l1", 0);
h1.Levels.Add(l1);
var p1 = new Property("[p1]", "p1");
l1.Properties.Add(p1);
//set the object to test
var mcw = new MetadataCsvWriter(filename);
mcw.Write(metadata);
//Assertion
FileAssert.AreEqual(expectedFilename, filename);
}
private void OnCaptureViewpointButtonClick(object sender, RibbonControlEventArgs e)
{
try
{
Utility.IsWWTInstalled();
WWTManager.IsValidMachine(Common.Globals.TargetMachine.MachineIP.ToString(), false);
Perspective perspective = WWTManager.GetCameraView();
if (perspective != null)
{
var dialog = new CaptureViewpoint();
System.Windows.Interop.WindowInteropHelper helper = new System.Windows.Interop.WindowInteropHelper(dialog);
helper.Owner = (IntPtr)ThisAddIn.ExcelApplication.Hwnd;
perspective.Name = Resources.DefaultViewpointText;
var viewModel = new ViewpointViewModel(perspective);
viewModel.IsButtonEnabled = true;
viewModel.RequestClose += new EventHandler(dialog.OnRequestClose);
dialog.DataContext = viewModel;
dialog.ShowDialog();
// WPF dialog does not have dialog result
if (dialog.DialogResult.HasValue && dialog.DialogResult.Value)
{
if (!string.IsNullOrWhiteSpace(perspective.Name))
{
// Fire it only when valid value set
this.GetViewpointClicked.OnFire(perspective, new EventArgs());
}
}
viewModel.RequestClose -= new EventHandler(dialog.OnRequestClose);
dialog.Close();
}
}
catch (CustomException ex)
{
Ribbon.ShowError(ex.HasCustomMessage ? ex.Message : Resources.LayerOperationError);
}
catch (Exception exception)
{
Logger.LogException(exception);
Ribbon.ShowError(Resources.DefaultErrorMessage);
}
}
public void PerspectiveConstructorTest()
{
string lookAt = "Earth";
string referenceFrame = "Earth";
bool hasRADec = false;
string observingTime = "2/25/2011 7:24:01 AM";
string timeRate = "1";
string zoomText = "9932 km";
string viewToken = "SD8834DFA";
string latitude = "30.0";
string longitude = "30.0";
string zoom = "2.0";
string rotation = ".3";
string lookAngle = "1.5";
Perspective target = new Perspective(lookAt, referenceFrame, hasRADec, latitude, longitude, zoom, rotation, lookAngle, observingTime, timeRate, zoomText, viewToken);
Assert.IsNotNull(target);
}
/**
* Constructor
*/
public DescriptorData()
{
contents = new List <ChapterSummary>();
cursors = new List <CustomCursor>();
buttons = new List <CustomButton>();
arrows = new List <CustomArrow>();
title = null;
description = null;
guiType = -1;
defaultClickAction = DefaultClickAction.SHOW_DETAILS;
perspective = Perspective.REGULAR;
dragBehaviour = DragBehaviour.CONSIDER_NON_TARGETS;
playerMode = MODE_PLAYER_1STPERSON;
graphicConfig = GRAPHICS_WINDOWED;
projectName = ENGINE_EXECUTION;
versionNumber = "0";
keyboardNavigationEnabled = false;
}
/// <summary>
/// Performs semantic conversion, validation on a command AST and creates a <see cref="DbCommandTree"/>
/// </summary>
/// <param name="astExpr">Abstract Syntax Tree of the command</param>
/// <param name="perspective">perspective</param>
/// <param name="parserOptions">parser options<seealso cref="ParserOptions"/></param>
/// <param name="parameters">ordinary command parameters</param>
/// <returns>a parse result with a valid command tree</returns>
/// <remarks>Parameters name/types must be bound before invoking this method</remarks>
/// <exception cref="System.Data.EntityException">Thrown when Syntatic or Semantic rules are violated and the query cannot be accepted.</exception>
/// <exception cref="System.Data.MetadataException">Thrown as inner exception of a EntityException when metadata related service requests fail.</exception>
/// <exception cref="System.Data.MappingException">Thrown as inner exception of a EntityException when mapping related service requests fail.</exception>
/// <remarks>
/// This method is not thread safe.
/// </remarks>
/// <seealso cref="ParserOptions"/>
/// <seealso cref="DbCommandTree"/>
private static ParseResult AnalyzeCommandSemantics(AST.Node astExpr,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters)
{
ParseResult result = AnalyzeSemanticsCommon(astExpr, perspective, parserOptions, parameters, null /*variables*/,
(analyzer, astExpression) =>
{
var parseResultInternal = analyzer.AnalyzeCommand(astExpression);
Debug.Assert(parseResultInternal != null, "parseResultInternal != null post-condition FAILED");
Debug.Assert(parseResultInternal.CommandTree != null, "parseResultInternal.CommandTree != null post-condition FAILED");
return(parseResultInternal);
});
return(result);
}
void FixedUpdate()
{
if (firstUpdate || view != previous)
{
if (FP)
{
FP.enabled = false;
}
if (TP)
{
TP.enabled = false;
}
if (TOP)
{
TOP.enabled = false;
}
if (FIX)
{
FIX.enabled = false;
}
if (FP && view == Perspective.firstPerson)
{
FP.enabled = true;
}
else if (TP && view == Perspective.thirdPerson)
{
TP.enabled = true;
}
else if (TOP && view == Perspective.topView)
{
TOP.enabled = true;
}
else if (FIX && view == Perspective.topViewFixed)
{
FIX.enabled = true;
}
previous = view;
firstUpdate = false;
}
if (view == Perspective.topViewFixed)
{
FIX.transform.rotation = Quaternion.LookRotation(Vector3.down);
}
}
public void StartPerspective_BWAB_Test1()
{
_logger.Info("{}の実行を開始します", nameof(StartPerspective_BWAB_Test1));
string PERSPECTIVE_NAME1 = "TestPerspective1";
string PERSPECTIVE_NAME2 = "TestPerspective2";
List <IContentBuilder> contentBuilders = new List <IContentBuilder>();
contentBuilders.Add(BuildContentBuilder("MyContent1"));
contentBuilders.Add(BuildContentBuilder("MyContent2"));
// テスト対象の生成と設定
var manager = new HarmonicManager();
manager.Verify(contentBuilders);
var dict = new Dictionary <string, string>();
dict.Add("MyFrameA", "MyContent1");
var perspective = new Perspective(PERSPECTIVE_NAME1, ArbitrationMode.AWAB, dict, manager);
manager.RegisterPerspective(perspective);
var dict2 = new Dictionary <string, string>();
dict2.Add("MyFrameB", "MyContent2");
var perspective2 = new Perspective(PERSPECTIVE_NAME2, ArbitrationMode.BWAB, dict2, manager);
manager.RegisterPerspective(perspective2);
manager.StartPerspective(PERSPECTIVE_NAME1);
// テスト対象のロジック呼び出し
manager.StartPerspective(PERSPECTIVE_NAME2);
// TODO: ここに、テストコードを実装する
var stack_MyFrameA = manager._FrameList.GetContentStack("MyFrameA");
Assert.Single(stack_MyFrameA);
var stack_MyFrameB = manager._FrameList.GetContentStack("MyFrameB");
Assert.Single(stack_MyFrameB);
}
protected Shape3C()
{
lines = new List <Line>();
invisibleLines = new List <Line>();
surfaces = new List <Surface>();
points = new List <Point>();
transformPoints = new List <Point>();
// transform matrix initialization
rotateX = new RotateX(0);
rotateY = new RotateY(0);
rotateZ = new RotateZ(0);
movePersp = new PerspectiveMove(60, 0, 0);
rotatePhi = new RotatePhi(0);
rotateTet = new RotateTheta(0);
perspectiveM = new Perspective(30);
move = new Move(0, 0, 0);
scale = new Scale(1);
}
public void LatitudeTest()
{
string lookAt = "Earth";
string referenceFrame = "Earth";
bool hasRADec = false;
string observingTime = "2/25/2011 7:24:01 AM";
string timeRate = "1";
string zoomText = "9932 km";
string viewToken = "SD8834DFA";
string latitude = "30.0";
string longitude = "30.0";
string zoom = "2.0";
string rotation = ".3";
string lookAngle = "1.5";
Perspective target = new Perspective(lookAt, referenceFrame, hasRADec, latitude, longitude, zoom, rotation, lookAngle, observingTime, timeRate, zoomText, viewToken);
string expected = latitude;
string actual = target.Latitude;
Assert.AreEqual(expected, actual);
}
public EntityState PlayerEntityState(Perspective perspective = Perspective.My)
{
if (_state == null)
{
return(null);
}
if (perspective == Perspective.My)
{
return(_state.Objects.FirstOrDefault(e => e.IsPlayer && e.Side == MySide));
}
if (perspective == Perspective.Opponent)
{
return(_state.Objects.FirstOrDefault(e => e.IsPlayer && e.Side == OpponentsSide));
}
return(null);
}
/// <summary>
/// Performs semantic conversion, validation on a query command AST and creates a <see cref="DbLambda"/>
/// </summary>
/// <param name="astQueryCommand">Abstract Syntax Tree of the query command</param>
/// <param name="perspective">perspective</param>
/// <param name="parserOptions">parser options<seealso cref="ParserOptions"/></param>
/// <param name="parameters">ordinary command parameters</param>
/// <param name="variables">command free variables</param>
/// <remarks>Parameters name/types must be bound before invoking this method</remarks>
/// <exception cref="System.Data.EntityException">Thrown when Syntatic or Semantic rules are violated and the query cannot be accepted.</exception>
/// <exception cref="System.Data.MetadataException">Thrown as inner exception of a EntityException when metadata related service requests fail.</exception>
/// <exception cref="System.Data.MappingException">Thrown as inner exception of a EntityException when mapping related service requests fail.</exception>
/// <remarks>
/// This method is not thread safe.
/// </remarks>
/// <seealso cref="ParserOptions"/>
/// <seealso cref="DbExpression"/>
private static DbLambda AnalyzeQueryExpressionSemantics(AST.Node astQueryCommand,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters,
IEnumerable <DbVariableReferenceExpression> variables)
{
return(AnalyzeSemanticsCommon(
astQueryCommand,
perspective,
parserOptions,
parameters,
variables,
(analyzer, astExpr) =>
{
DbLambda lambda = analyzer.AnalyzeQueryCommand(astExpr);
Debug.Assert(null != lambda, "null != lambda post-condition FAILED");
return lambda;
}));
}
public void LongitudeTest()
{
string lookAt = "Earth";
string referenceFrame = "Earth";
bool hasRADec = false;
string observingTime = "2/25/2011 7:24:01 AM";
string timeRate = "1";
string zoomText = "9932 km";
string viewToken = "SD8834DFA";
string latitude = "30.0";
string longitude = "30.0";
string zoom = "2.0";
string rotation = ".3";
string lookAngle = "1.5";
Perspective target = new Perspective(lookAt, referenceFrame, hasRADec, latitude, longitude, zoom, rotation, lookAngle, observingTime, timeRate, zoomText, viewToken);
string expected = longitude;
string actual = target.Longitude;
Assert.AreEqual(expected, actual);
}
private unsafe void ReaderThread()
{
lock (this){
//Het engelse gedeelte is code van kai
//Maar omdat de code kris kras door de applicatie verdwijnt
//Zal niet meer te herkennen zijn wat van hem is of nog maar te zeggen dat het van hem is
//Toch ter ere van zijn werk noteren we zijn naam Kai.
//TextWriter tw = new StreamWriter("d:\\temp\\depthdump.txt");
int[] depth;
UInt16[] rgb;
try { this.context.WaitAndUpdateAll(); }catch (Exception) { }
Perspective p = new Perspective(DateTime.Now);
GImage.GetMetaData(p.ImgMD);
GDepth.GetMetaData(p.DepthMD);
BeeldOpslag.Instance.RegisterPerspective(p);
LOG.Instance.publishMessage("Start take picture thread ID " + Thread.CurrentThread.ManagedThreadId + " DONE");
}
}
/// <summary>
/// Compiles an eSQL command producing a validated <see cref="DbCommandTree"/>.
/// </summary>
/// <param name="commandText">eSQL command text</param>
/// <param name="perspective">perspective</param>
/// <param name="parserOptions">parser options<seealso cref="ParserOptions"/></param>
/// <param name="parameters">ordinary parameters</param>
/// <param name="parseResult"></param>
/// <returns>A parse result with the command tree produced by parsing the given command.</returns>
/// <exception cref="System.Data.EntityException">Thrown when Syntatic or Semantic rules are violated and the query cannot be accepted</exception>
/// <exception cref="System.Data.MetadataException">Thrown when metadata related service requests fail</exception>
/// <exception cref="System.Data.MappingException">Thrown when mapping related service requests fail</exception>
/// <remarks>
/// This method is not thread safe.
/// </remarks>
/// <seealso cref="ParserOptions"/>
/// <seealso cref="DbCommandTree"/>
internal static ParseResult Compile(string commandText,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters)
{
ParseResult result = CompileCommon(commandText, perspective, parserOptions,
(astCommand, validatedParserOptions) =>
{
var parseResultInternal = AnalyzeCommandSemantics(astCommand, perspective, validatedParserOptions, parameters);
Debug.Assert(parseResultInternal != null, "parseResultInternal != null post-condition FAILED");
Debug.Assert(parseResultInternal.CommandTree != null, "parseResultInternal.CommandTree != null post-condition FAILED");
TypeHelpers.AssertEdmType(parseResultInternal.CommandTree);
return(parseResultInternal);
});
return(result);
}
public WrappingScreenGrid(Texture2D texture, byte[,] frames, Vector2 cellSize, Perspective perspective)
{
Texture = texture;
FrameGrid = frames;
CellSize = cellSize;
Perspective = perspective;
XHead = 0;
YHead = 0;
XOffsetWest = 0;
XOffsetEast = 0;
YOffsetNorth = 0;
YOffsetSouth = 0;
Width = frames.GetLength(0);
Height = frames.GetLength(1);
WrappedWidth = 0;
WrappedHeight = 0;
Position = Vector2.Zero;
}
private static TResult AnalyzeSemanticsCommon <TResult>(
Node astExpr,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters,
IEnumerable <DbVariableReferenceExpression> variables,
Func <SemanticAnalyzer, Node, TResult> analysisFunction)
where TResult : class
{
DebugCheck.NotNull(astExpr);
DebugCheck.NotNull(perspective);
TResult result = null;
try
{
//
// Invoke semantic analysis
//
var analyzer = (new SemanticAnalyzer(SemanticResolver.Create(perspective, parserOptions, parameters, variables)));
result = analysisFunction(analyzer, astExpr);
}
//
// Wrap MetadataException as EntityException inner exception
//
catch (MetadataException metadataException)
{
var message = Strings.GeneralExceptionAsQueryInnerException("Metadata");
throw new EntitySqlException(message, metadataException);
}
//
// Wrap MappingException as EntityException inner exception
//
catch (MappingException mappingException)
{
var message = Strings.GeneralExceptionAsQueryInnerException("Mapping");
throw new EntitySqlException(message, mappingException);
}
return(result);
}
private static TResult AnalyzeSemanticsCommon <TResult>(AST.Node astExpr,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters,
IEnumerable <DbVariableReferenceExpression> variables,
Func <SemanticAnalyzer, AST.Node, TResult> analysisFunction)
where TResult : class
{
TResult result = null;
try
{
//
// Validate arguments
//
EntityUtil.CheckArgumentNull(astExpr, "astExpr");
EntityUtil.CheckArgumentNull(perspective, "perspective");
//
// Invoke semantic analysis
//
SemanticAnalyzer analyzer = (new SemanticAnalyzer(SemanticResolver.Create(perspective, parserOptions, parameters, variables)));
result = analysisFunction(analyzer, astExpr);
}
//
// Wrap MetadataException as EntityException inner exception
//
catch (System.Data.MetadataException metadataException)
{
throw EntityUtil.EntitySqlError(System.Data.Entity.Strings.GeneralExceptionAsQueryInnerException("Metadata"), metadataException);
}
//
// Wrap MappingException as EntityException inner exception
//
catch (System.Data.MappingException mappingException)
{
throw EntityUtil.EntitySqlError(System.Data.Entity.Strings.GeneralExceptionAsQueryInnerException("Mapping"), mappingException);
}
return(result);
}
public void updateEnvironment(Perspective perspective)
{
if (curPerspective == Perspective.twoD)
{
currentZAxis = thePlayer.transform.position.z;
thePlayer.transform.position = GameManager.get2DPosition(thePlayer.transform.position);
theLight.transform.position = new Vector3(thePlayer.transform.position.x, thePlayer.transform.position.y, thePlayer.transform.position.z - 0.1f);
mainCamera.orthographic = true;
mainCamera.fieldOfView = 60;
}
else
{
thePlayer.transform.position = GameManager.get3DPosition(thePlayer.transform.position);
theLight.transform.position = new Vector3(thePlayer.transform.position.x - .1f, thePlayer.transform.position.y, thePlayer.transform.position.z);
mainCamera.orthographic = false;
mainCamera.fieldOfView = 60;
}
SwitchObstaclePerspectives();
}
public void RestoreActiveContent(Perspective ActivePerspective)
{
if (!ActiveContents.ContainsKey(ActivePerspective))
{
return;
}
foreach (var activeContent in ActiveContents[ActivePerspective])
{
foreach (var content in Core.MainForm.panelMain.Contents)
{
if (content.ToString() == activeContent)
{
var handler = content.DockHandler;
handler.IsHidden = false;
handler.Show();
break;
}
}
}
}
private static void BatchGenerateMapping(string gridPath, string warpPath, string transformer, string mappingPath, string metadataPath)
{
if (!CanSkip(gridPath, warpPath, transformer, mappingPath, metadataPath))
{
KeyValuePair<List<Shape>, int[]> gridData = GetShapes(gridPath);
KeyValuePair<List<Shape>, int[]> warpData = GetShapes(warpPath);
List<Shape> gridShapes = gridData.Key;
int[] gridDim = gridData.Value;
List<Shape> warpShapes = warpData.Key;
int[] warpDim = warpData.Value;
if (gridDim[0] != warpDim[0] || gridDim[1] != warpDim[1])
{
throw new InvalidDataException("Grid and Warp images are not same dimensions");
}
List<KeyValuePair<Shape, Shape>> ShapeList = FindPairing(gridShapes, warpShapes);
Transformer transformerobj;
switch (transformer)
{
case "1.5orderpoly":
transformerobj = new OneFiveOrderPoly();
break;
case "bilinear":
transformerobj = new Bilinear();
break;
case "perspective":
transformerobj = new Perspective();
break;
default:
throw new InvalidDataException("Invalid transformer argument");
}
Dictionary<Point, Point> mapping = GenerateMapping(ShapeList, transformerobj, gridDim[0], gridDim[1]);
MyJSON.SaveMapping(gridDim[0], gridDim[1], mapping, transformer, mappingPath, metadataPath);
}
}
public TwoDPerspective(Perspective perspective)
{
mPerspective = perspective;
}
public void Draw(System.Drawing.Graphics graphics, Func<OpenMetaverse.Vector3, System.Drawing.Point> to2D, Action redraw, Perspective perspective)
{
}
public virtual void Draw(Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
foreach (var activeArea in WindowStates.
Aggregate(new List<IDiagramDrawable>(), (l, w) => {
l.AddRange(w.Features.Where(f => f is IDiagramDrawable).Select(f => f as IDiagramDrawable));
return l;
}))
activeArea.Draw(graphics, to2D, redraw, perspective);
}
/// <summary>
/// Takes user to the viewpoint
/// </summary>
/// <param name="perspective">perspective object</param>
private static void GotoViewpointFromData(Perspective perspective)
{
try
{
Utility.IsWWTInstalled();
WWTManager.IsValidMachine(Common.Globals.TargetMachine.MachineIP.ToString(), false);
WWTManager.SetCameraView(perspective);
if (TargetMachine.DefaultIP.ToString() == Common.Globals.TargetMachine.MachineIP.ToString())
{
Utility.ShowWWT();
}
}
catch (CustomException ex)
{
// Earth or solar system
if (!perspective.LookAt.Equals(Common.Constants.SkyLookAt, StringComparison.OrdinalIgnoreCase))
{
// If Lat and Lon values were not mapped or invalid, show error
float validValue;
if (!float.TryParse(perspective.Latitude, out validValue) || !float.TryParse(perspective.Longitude, out validValue))
{
Ribbon.ShowError(Resources.GotoViewpointfromInvalidLatLonError);
}
}
else if (perspective.HasRADec)
{
// If RA and Dec values were not mapped or invalid, show error.
float validValue;
if (!float.TryParse(perspective.RightAscention, out validValue) || !float.TryParse(perspective.Declination, out validValue))
{
Ribbon.ShowError(Resources.GotoViewpointfromInvalidRaDecError);
}
}
else
{
Ribbon.ShowError(ex.HasCustomMessage ? ex.Message : Resources.LayerOperationError);
}
}
}
public void Draw(Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
}
public void setPerspective(Perspective perspective)
{
this.perspective = perspective;
}
public void Draw(Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
if (mCurrentState != null) {
if (mRedraw == null)
mRedraw = redraw;
mCurrentState.Draw(graphics, to2D, redraw, perspective);
}
}
public SchemaUpdater(Environment environment, Perspective perspective)
{
this.environment = environment;
this.perspective = perspective;
}
public void Draw(Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
if (perspective == Perspective.Map) {
if (!mRedraws.Contains(redraw))
mRedraws.Add(redraw);
Point bottomRight = to2D(mFarCorner);
graphics.DrawImage(mMap, -bottomRight.X * mLeftScaleX, -bottomRight.Y * mLeftScaleY, bottomRight.X * mScaleX, bottomRight.Y * mScaleY);
DrawTarget(graphics, to2D, bottomRight);
if (mState == Plugins.State.FirstLoad || mState == Plugins.State.Prepped)
graphics.DrawLine(Pens.Blue, GetPoint(mStartA, to2D, bottomRight), GetPoint(mStartB, to2D, bottomRight));
else {
graphics.DrawLine(Pens.Red, GetPoint(mStartA, to2D, bottomRight), GetPoint(mStartB, to2D, bottomRight));
graphics.DrawLines(Pens.Red, mRoute.Select(v => GetPoint(v, to2D, bottomRight)).ToArray());
}
Point location = GetPoint(mCore.Position, to2D, bottomRight);
graphics.FillEllipse(Brushes.Red, location.X - mR, location.Y - mR, mR * 2, mR * 2);
Point lookAt = GetPoint(mCore.Position + mCore.Orientation.LookAtVector, to2D, bottomRight);
graphics.DrawLine(Pens.Green, location, lookAt);
}
}
public static void Run(Environment environment, Perspective perspective, params string[] args)
{
WinFormRunner.Run<ClientForm>(environment, perspective, args);
}
public void PerspectiveConstructorTest()
{
string lookAt = "Earth";
string referenceFrame = "Earth";
bool hasRADec = false;
string observingTime = "2/25/2011 7:24:01 AM";
string timeRate = "1";
string zoomText = "9932 km";
string viewToken = "SD8834DFA";
string latitude = "30.0";
string longitude = "30.0";
string zoom = "2.0";
string rotation = ".3";
string lookAngle = "1.5";
Perspective target = new Perspective(lookAt, referenceFrame, hasRADec, latitude, longitude, zoom, rotation, lookAngle, observingTime, timeRate, zoomText, viewToken);
Assert.IsNotNull(target);
}
public DotAxis(string name, Perspective perspective)
: this(name, AxisBinding.NotSet, perspective)
{
}
public void Draw(System.Drawing.Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
//Do nothing
}
public DotAxis(string name, AxisBinding binding, Perspective perspective)
: base(name, binding)
{
mPerspective = perspective;
Init();
}
/**
* Constructor
*/
public DescriptorData()
{
contents = new List<ChapterSummary>();
cursors = new List<CustomCursor>();
buttons = new List<CustomButton>();
arrows = new List<CustomArrow>();
title = null;
description = null;
guiType = -1;
defaultClickAction = DefaultClickAction.SHOW_DETAILS;
perspective = Perspective.REGULAR;
dragBehaviour = DragBehaviour.CONSIDER_NON_TARGETS;
playerMode = MODE_PLAYER_1STPERSON;
graphicConfig = GRAPHICS_WINDOWED;
projectName = ENGINE_EXECUTION;
versionNumber = "0";
keyboardNavigationEnabled = false;
}
/// <summary>
/// Set the perspective properties in WWT
/// </summary>
/// <param name="perspective">Perspective object</param>
/// <returns>True if the update request is sent successfully</returns>
public static void SetCameraView(Perspective perspective)
{
if (perspective != null)
{
string url = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
Constants.SetModeCommand,
Globals.TargetMachine.MachineIP,
perspective.LookAt);
if (IsValidResponse(request.Send(url, string.Empty, false)))
{
if (perspective.LookAt.Equals(Constants.EarthLookAt, StringComparison.OrdinalIgnoreCase) ||
perspective.LookAt.Equals(Constants.SkyLookAt, StringComparison.OrdinalIgnoreCase))
{
url = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
Constants.SetCameraViewCommand,
Globals.TargetMachine.MachineIP,
perspective.HasRADec ? perspective.Declination : perspective.Latitude,
perspective.HasRADec ? perspective.RightAscention : perspective.Longitude,
perspective.Zoom,
perspective.Rotation,
perspective.LookAngle,
perspective.TimeRate,
perspective.ObservingTime);
}
else
{
url = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
Constants.SetCameraViewCommandWithReferenceFrame,
Globals.TargetMachine.MachineIP,
perspective.HasRADec ? perspective.Declination : perspective.Latitude,
perspective.HasRADec ? perspective.RightAscention : perspective.Longitude,
perspective.Zoom,
perspective.Rotation,
perspective.LookAngle,
perspective.ReferenceFrame,
perspective.ViewToken,
perspective.TimeRate,
perspective.ObservingTime);
}
request.Send(url, string.Empty, false);
}
}
}
/// <summary>
/// DrawSelected any relevant information about this input onto a diagram.
/// </summary>
/// <param name="perspective">The perspective to render along.</param>
/// <param name="graphics">The graphics object to draw with.</param>
public void Draw(Func<Vector3, Point> to2D, Graphics graphics, Rectangle clipRectangle, Action redraw, Perspective perspective)
{
if (perspective == Perspective.Map)
return;
if (!mRedraws.Contains(redraw))
mRedraws.Add(redraw);
if (!mDraw)
return;
Vector3 top = new Vector3(0f, (float)mWidth, 0f) * mOrientation.Quaternion;
Vector3 side = new Vector3(0f, 0f, (float)-mHeight) * mOrientation.Quaternion;
Vector3 miniTop = Vector3.Zero;
Vector3 miniSide = Vector3.Zero;
using (Pen p = new Pen(mColour, 3f)) {
Point bottomR = to2D(mTopLeft + top + side);
graphics.DrawLine(p, to2D(mTopLeft), to2D(mTopLeft + top));
graphics.DrawLine(p, to2D(mTopLeft), to2D(mTopLeft + side));
graphics.DrawLine(p, to2D(mTopLeft + top), bottomR);
graphics.DrawLine(p, to2D(mTopLeft + side), bottomR);
}
using (Brush b = new SolidBrush(mColour)) {
graphics.FillPolygon(Brushes.Red, new Point[] {
to2D(mTopLeft),
to2D(mTopLeft + top),
to2D(mTopLeft + top + side),
to2D(mTopLeft + side)
});
graphics.DrawPolygon(Pens.Black, new Point[] {
to2D(mTopLeft),
to2D(mTopLeft + top),
to2D(mTopLeft + top + side),
to2D(mTopLeft + side)
});
}
if (mDrawEye) {
float perspectiveLineScale = 5f;
Vector3 topLeftLine = ((mTopLeft - mCoordinator.EyePosition) * perspectiveLineScale) + mCoordinator.EyePosition;
Vector3 topRightLine = (((mTopLeft + top) - mCoordinator.EyePosition) * perspectiveLineScale) + mCoordinator.EyePosition;
Vector3 bottomLeftLine = (((mTopLeft + top + side) - mCoordinator.EyePosition) * perspectiveLineScale) + mCoordinator.EyePosition;
Vector3 bottomRightLine = (((mTopLeft + side) - mCoordinator.EyePosition) * perspectiveLineScale) + mCoordinator.EyePosition;
Point eye = to2D(mCoordinator.EyePosition);
graphics.DrawLine(Pens.DarkViolet, eye, to2D(topLeftLine));
graphics.DrawLine(Pens.DarkViolet, eye, to2D(topRightLine));
graphics.DrawLine(Pens.DarkViolet, eye, to2D(bottomLeftLine));
graphics.DrawLine(Pens.DarkViolet, eye, to2D(bottomRightLine));
Vector3 look = new Vector3((float)ScreenDistance, 0f, 0f) * mOrientation.Quaternion;
graphics.DrawLine(Pens.CornflowerBlue, eye, to2D(look + mCoordinator.EyePosition));
Vector3 normal = new Vector3((float)(Diagonal / 2.0), 0f, 0f) * mOrientation.Quaternion;
graphics.DrawLine(Pens.Crimson, to2D(Centre), to2D(normal + Centre));
using (Pen p = new Pen(Color.BlueViolet, 4f))
graphics.DrawLine(p, to2D(look + mCoordinator.EyePosition), to2D(Centre));
}
}
/// <summary>
/// Takes user to the viewpoint
/// </summary>
/// <param name="perspective">perspective object</param>
private static void GotoViewpoint(Perspective perspective)
{
try
{
Utility.IsWWTInstalled();
WWTManager.IsValidMachine(Common.Globals.TargetMachine.MachineIP.ToString(), false);
WWTManager.SetCameraView(perspective);
if (TargetMachine.DefaultIP.ToString() == Common.Globals.TargetMachine.MachineIP.ToString())
{
Utility.ShowWWT();
}
}
catch (CustomException ex)
{
Ribbon.ShowError(ex.HasCustomMessage ? ex.Message : Resources.LayerOperationError);
}
}
public void Draw(Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
if (perspective == Perspective.Map)
return;
if (!mRedraws.Contains(redraw))
mRedraws.Add(redraw);
if (mEnabled) {
using (Pen p = new Pen(Color.Black, 3f)) {
Vector3 l = new Vector3(0f, -140, 0f) * mKinectOrientation.Quaternion;
Vector3 r = new Vector3(0f, 140, 0f) * mKinectOrientation.Quaternion;
graphics.DrawLine(p, to2D(mKinectPosition + l), to2D(mKinectPosition + r));
}
using (Brush b = new SolidBrush(Color.FromArgb(32, Color.Blue))) {
int hFoV = 57 / 2;
int vFoV = 43 / 2;
Vector3 range = new Vector3(3500f, 0f, 0f);
Vector3 topLeft = range * (new Rotation(vFoV, -hFoV) + mKinectOrientation).Quaternion;
Vector3 topRight = range * (new Rotation(vFoV, hFoV) + mKinectOrientation).Quaternion;
Vector3 bottomLeft = range * (new Rotation(-vFoV, -hFoV) + mKinectOrientation).Quaternion;
Vector3 bottomRight = range * (new Rotation(-vFoV, hFoV) + mKinectOrientation).Quaternion;
Point centreP = to2D(mKinectPosition);
Point topLeftP = to2D(topLeft + mKinectPosition);
Point topRightP = to2D(topRight + mKinectPosition);
Point bottomLeftP = to2D(bottomLeft + mKinectPosition);
Point bottomRightP = to2D(bottomRight + mKinectPosition);
graphics.FillPolygon(b, new Point[] { centreP, topLeftP, topRightP, centreP });
graphics.FillPolygon(b, new Point[] { centreP, bottomLeftP, bottomRightP, centreP });
graphics.FillPolygon(b, new Point[] { centreP, topLeftP, bottomLeftP, centreP });
graphics.FillPolygon(b, new Point[] { centreP, topRightP, bottomRightP, centreP });
}
}
}
public void Draw(Graphics g, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
if (!mRedraws.Contains(redraw))
mRedraws.Add(redraw);
if (!mEnabled)
return;
if (mDrawRoom && sCorners.Count > 1) {
g.DrawPolygon(Pens.Black, sCorners.Select(v => to2D(v + mAnchor)).ToArray());
if (mDrawLabels) {
Font font = SystemFonts.DefaultFont;
Vector3 edgeB = Big + RoomPosition;
Vector3 edgeS = Small + RoomPosition;
Vector3 centre = edgeS + (Size / 2f);
string w = String.Format("Width: {0:.#}", Size.Y);
string h = String.Format("Height: {0:.#}", Size.Z);
string d = String.Format("Depth: {0:.#}", Size.X);
if (perspective == Perspective.X) {
PH(g, new Vector3(0f, edgeB.Y, centre.Z), h, to2D, font);
PW(g, new Vector3(0f, centre.Y, edgeS.Z), w, to2D, font);
}
if (perspective == Perspective.Y) {
PH(g, new Vector3(edgeS.X, 0f, centre.Z), h, to2D, font);
PW(g, new Vector3(centre.X, 0f, edgeS.Z), d, to2D, font);
}
if (perspective == Perspective.Z) {
PH(g, new Vector3(centre.X, edgeB.Y, 0f), d, to2D, font);
PW(g, new Vector3(edgeS.X, centre.Y, 0f), w, to2D, font);
}
}
}
foreach (var projector in mProjectors.Where(p => p.DrawDiagram))
projector.Draw(g, to2D, redraw, perspective);
}
/// <summary>
/// Get perspective based on the layer mapping and the row data
/// </summary>
/// <param name="layerMap">layer map object</param>
/// <param name="rowData">row data collection</param>
/// <returns>Perspective object</returns>
private static Perspective GetPerspectiveFromLayerRowData(LayerMap layerMap, Collection<string> rowData)
{
Perspective perspective = null;
if (layerMap.LayerDetails.Group != null)
{
var referenceFrame = layerMap.LayerDetails.Group.GetReferenceFrame();
var referenceFramePath = layerMap.LayerDetails.Group.Path;
if (referenceFramePath.StartsWith(Common.Constants.SkyFramePath, StringComparison.OrdinalIgnoreCase))
{
perspective = new Perspective(Common.Constants.SkyLookAt, referenceFrame, true, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.SkyZoomTextDefaultValue, string.Empty);
float hours = 0;
string rowValueForRA = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.RA)];
if (layerMap.LayerDetails.RAUnit == AngleUnit.Hours)
{
// If hours data, send it as is
perspective.RightAscention = rowValueForRA;
}
else if (float.TryParse(rowValueForRA, out hours))
{
// If degrees data, divide it by 15 and send
perspective.RightAscention = (hours / 15).ToString(System.Globalization.CultureInfo.InvariantCulture);
}
else
{
// Else send it as is as it cannot be converted to degrees
perspective.RightAscention = rowValueForRA;
}
perspective.Declination = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.Dec)];
}
else
{
if (referenceFramePath.StartsWith(Common.Constants.EarthFramePath, StringComparison.OrdinalIgnoreCase))
{
perspective = new Perspective(Common.Constants.EarthLookAt, referenceFrame, false, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.EarthZoomTextDefaultValue, string.Empty);
}
else
{
perspective = new Perspective(Common.Constants.SolarSystemLookAt, referenceFrame, false, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.EarthZoomTextDefaultValue, string.Empty);
}
perspective.Latitude = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.Lat)];
perspective.Longitude = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.Long)];
}
}
// Update Perspective based on current state
Perspective currentPerspective = null;
try
{
currentPerspective = WWTManager.GetCameraView();
}
catch (CustomException)
{
// Ignore.
}
if (currentPerspective != null)
{
perspective.ObservingTime = currentPerspective.ObservingTime;
perspective.TimeRate = currentPerspective.TimeRate;
perspective.Rotation = currentPerspective.Rotation;
perspective.LookAngle = currentPerspective.LookAngle;
perspective.Zoom = currentPerspective.Zoom;
}
return perspective;
}
public void GotoViewpointTest()
{
bool createdWtmlKey = false;
try
{
createdWtmlKey = CreateWwtKeyIfNotExists();
Common.Globals_Accessor.wwtManager = new WWTManager(new WWTMockRequest());
Common.Globals_Accessor.TargetMachine = new TargetMachine("localhost");
Perspective perspective = new Perspective(Common.Constants.EarthLookAt, Common.Constants.EarthLookAt, false, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.EarthZoomTextDefaultValue, string.Empty);
WorkflowController_Accessor.GotoViewpoint(perspective);
}
finally
{
if (createdWtmlKey)
{
// Delete the registry key if it is created by this test case.
Registry.ClassesRoot.DeleteSubKey(@".wtml", false);
}
}
}
public void Draw(Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
if (!Active || perspective != Perspective.Map)
return;
PointF final = new PointF(FinalPoint.X, FinalPoint.Y);
graphics.DrawPolygon(Pens.Red, mPoints.Concat(new Vector2[] { FinalPoint }).Select(p => to2D(new Vector3(p.X, p.Y, 0f))).ToArray());
}
public void Draw(Graphics graphics, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
if (mCurrentInput != null)
mCurrentInput.Draw(graphics, to2D, redraw, perspective);
}
public static Perspective GetCameraView()
{
Perspective perspective = null;
string url = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
Constants.GetCameraViewCommand,
Globals.TargetMachine.MachineIP);
string response = request.Send(url, string.Empty, false);
XmlDocument doc = new XmlDocument();
doc.LoadXml(response);
XmlNode viewStateNode = doc.SelectSingleNode(Constants.XPathStringForViewState);
if (viewStateNode != null)
{
if (GetAttributeValue(viewStateNode, Constants.LookatAttribute).Equals(Constants.SkyLookAt, StringComparison.OrdinalIgnoreCase))
{
perspective = new Perspective(Common.Constants.SkyLookAt, Common.Constants.SkyReferenceFrame, true, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.SkyZoomTextDefaultValue, string.Empty);
perspective.RightAscention = GetAttributeValue(viewStateNode, Constants.RightAscentionAttribute);
perspective.Declination = GetAttributeValue(viewStateNode, Constants.DeclinationAttribute);
}
else
{
perspective = new Perspective(Common.Constants.EarthLookAt, Common.Constants.EarthLookAt, false, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.EarthZoomTextDefaultValue, string.Empty);
perspective.Latitude = GetAttributeValue(viewStateNode, Constants.LatAttribute);
perspective.Longitude = GetAttributeValue(viewStateNode, Constants.LongAttribute);
perspective.LookAngle = GetAttributeValue(viewStateNode, Constants.AngleAttribute);
}
perspective.LookAt = GetAttributeValue(viewStateNode, Constants.LookatAttribute);
perspective.ReferenceFrame = GetAttributeValue(viewStateNode, Constants.ReferenceFrameAttribute);
perspective.ViewToken = GetAttributeValue(viewStateNode, Constants.ViewTokenAttribute);
perspective.ZoomText = GetAttributeValue(viewStateNode, Constants.ZoomTextAttribute);
perspective.Rotation = GetAttributeValue(viewStateNode, Constants.RotationAttribute);
perspective.Zoom = GetAttributeValue(viewStateNode, Constants.ZoomAttribute);
perspective.TimeRate = GetAttributeValue(viewStateNode, Constants.TimeRateAttribute);
perspective.ObservingTime = GetAttributeValue(viewStateNode, Constants.ObservingTimeAttribute);
}
return perspective;
}
public void Draw(Graphics g, Func<Vector3, Point> to2D, Action redraw, Perspective perspective)
{
if (mDraw) {
Func<Vector3, Point> to2DR = v => to2D(Origin + (v * new Rotation(0.0, mOrientation.Yaw).Quaternion));
Point pos = to2DR(Vector3.Zero);
double range = 12500.0;
double y = range * Math.Tan(mGamma);
double zt = range * Math.Tan(mUpsideDown ? -mAlpha : mBeta);
double zb = range * Math.Tan(mUpsideDown ? -mBeta : mAlpha);
Quaternion q = new Rotation(-mOrientation.Pitch, 0.0).Quaternion;
Vector3 bse = new Vector3((float)range, 0f, 0f) * q;
Vector3 tl = new Vector3((float)range, (float)-y, (float)zt) * q;
Vector3 tr = new Vector3((float)range, (float)y, (float)zt) * q;
Vector3 bl = new Vector3((float)range, (float)-y, (float)zb) * q;
Vector3 br = new Vector3((float)range, (float)y, (float)zb) * q;
g.DrawLine(Pens.Red, pos, to2DR(bse));
g.DrawLine(Pens.Green, pos, to2DR(bl));
g.DrawLine(Pens.Green, pos, to2DR(br));
g.DrawLine(Pens.Blue, pos, to2DR(tl));
g.DrawLine(Pens.Blue, pos, to2DR(tr));
g.DrawLine(Pens.Violet, to2DR(new Vector3((float)mD, 0f, (float)-range)), to2DR(new Vector3((float)mD, 0f, (float)range)));
double betaH = mD / Math.Cos(P + mBeta);
double alphaH = mD / Math.Cos(P + mAlpha);
double betaY = mD * Math.Tan(P + mBeta);
double alphaY = mD * Math.Tan(P + mAlpha);
//g.DrawLine(Pens.Purple, pos, to2DR(new Vector3((float)mD, 0f, (float) betaY)));
//g.DrawLine(Pens.Purple, pos, to2DR(new Vector3((float)mD, 0f, (float) alphaY)));
//g.DrawLine(Pens.Purple, pos, to2DR(new Vector3((float)betaH, 0f, 0f) * new Rotation(((P + mBeta) * -180.0) / Math.PI, 0.0).Quaternion));
//g.DrawLine(Pens.Purple, pos, to2DR(new Vector3((float)alphaH, 0f, 0f) * new Rotation(((P + mAlpha) * -180.0) / Math.PI, 0.0).Quaternion));
if (mDrawLabels) {
Vector3 toScreen = new Vector3((float) mD, 0f, 0f) * new Rotation(0.0, mOrientation.Yaw).Quaternion;
Vector3 floor = new Vector3(0f, 0f, mProjectorPlugin.RoomPosition.Z + mProjectorPlugin.Small.Z);
Vector3 clearance = new Vector3(0f, 0f, (float) Clearance);
Vector3 toClearance = floor + clearance;
Font font = SystemFonts.DefaultFont;
using (Pen p2 = new Pen(Color.Black, 2f)) {
g.DrawLine(p2, pos, to2D(mProjectorPlugin.RoomPosition + mPosition + toScreen));
g.DrawString(String.Format("To Screen: {0:.#}cm", D / 10f), font, Brushes.Black, to2D(mProjectorPlugin.RoomPosition + mPosition + (toScreen / 2f)));
if (perspective == Perspective.X || perspective == Perspective.Y) {
Vector3 toCeiling = new Vector3(0f, 0f, RelativePosition.Z);
g.DrawString(String.Format("Z: {0:.#}cm", RelativePosition.Z / 10f), font, Brushes.Black, to2D(mProjectorPlugin.RoomPosition + mPosition + (toCeiling / 2f)));
g.DrawLine(p2, pos, to2D(mProjectorPlugin.RoomPosition + mPosition + toCeiling));
g.DrawString(String.Format("Clearance: {0:.#}cm", Clearance / 10f), font, Brushes.Black, to2D(floor + (clearance / 2f)));
g.DrawLine(p2, to2D(floor), to2D(toClearance));
} if (perspective == Perspective.X || perspective == Perspective.Z) {
Vector3 toSide = new Vector3(0f, RelativePosition.Y, 0f);
g.DrawString(String.Format("Y: {0:.#}cm", RelativePosition.Y / 10f), font, Brushes.Black, to2D(mProjectorPlugin.RoomPosition + mPosition + (toSide / 2f)));
g.DrawLine(p2, pos, to2D(mProjectorPlugin.RoomPosition + mPosition + toSide));
} if (perspective == Perspective.Y || perspective == Perspective.Z) {
Vector3 toFar = new Vector3(RelativePosition.X, 0f, 0f);
g.DrawString(String.Format("X: {0:.#}cm", RelativePosition.X / 10f), font, Brushes.Black, to2D(mProjectorPlugin.RoomPosition + mPosition + (toFar / 2f)));
g.DrawLine(p2, pos, to2D(mProjectorPlugin.RoomPosition + mPosition + toFar));
}
}
}
}
}
