/// <summary> /// 创建门店的构造函数 /// </summary> public WePoiBaseInfo(string bName, string prov, string city, string addr, string tel, List<string> cate, OffsetType offset, double lgt, double lat, List<WePhotoUrl> phList, string special, TimeSpan beg, TimeSpan end) { TkDebug.AssertArgumentNullOrEmpty(bName, "bName", null); TkDebug.AssertArgumentNullOrEmpty(prov, "prov", null); TkDebug.AssertArgumentNullOrEmpty(city, "city", null); TkDebug.AssertArgumentNullOrEmpty(addr, "addr", null); TkDebug.AssertArgumentNullOrEmpty(tel, "tel", null); TkDebug.AssertArgumentNull(cate, "cate", null); TkDebug.AssertArgumentNull(phList, "phList", null); TkDebug.AssertArgumentNullOrEmpty(special, "special", null); BusinessName = bName; Province = prov; City = city; Address = addr; Telephone = tel; Categories = cate; OffsetType = offset; Longitude = lgt; Latitude = lat; PhotoList = phList; Special = special; OpenTime = beg.ToString("hh\\:mm") + "-" + end.ToString("hh\\:mm"); }
protected void OnOffset(OffsetType type, double offsetX, double offsetY) { if (null != OffsetAction) { OffsetAction(this, type, offsetX, offsetY); } OnElementMovingAction(type, new Rect(_element.Left, _element.Top, _element.Width, _element.Height)); }
public Tritemius(string input, string key, OffsetType type) : base(input, key) { _encryptionType = type; if (type == OffsetType.Expression) { CompiledExpression = СompileExpression(); } }
public MoveAIAction(string target, float sp, FocusType focusT, OffsetType offsetT, int ang = 0, float dist = 0f, bool ine = true, float maxT = 0, int next = AIAction.NEXT_ACTION) : base(Type.MOVE, next) { targetId = target; speed = sp; focusType = focusT; offsetType = offsetT; angle = ang; distance = dist; inertia = ine; maxTime = maxT; }
public PatternOffset(OffsetType type, Whence whence, int offset) { if (OffsetType.MatchStart == type && Whence.Start == whence && offset < 0) { string msg = StringExtensions.Fi("Iris currently does not support negative a negative match start offset starting from the actual match start"); throw new AssertionViolationException(msg); } this.OffSetType = type; this.Whence = whence; this.Offset = offset; }
public void CanParseInitialOffsetFromConfig(string offsetType, OffsetType typeEnum) { string extensionPath = "AzureWebJobs:Extensions:EventHubs"; var options = TestHelpers.GetConfiguredOptions <EventHubOptions>( b => { b.AddEventHubs(); }, new Dictionary <string, string> { { $"{extensionPath}:InitialOffsetOptions:Type", offsetType } }); Assert.AreEqual(typeEnum, options.InitialOffsetOptions.Type); }
public static bool Validate(Rectangle area, List <Rectangle> offsetList, OffsetType offsetType = OffsetType.Column) { bool isValidate = true; if (offsetType == OffsetType.Column) { isValidate = ValidateColumn(area, offsetList); } else { isValidate = ValidateRow(area, offsetList); } return(isValidate); }
/// <summary> /// Read the vertical offset type /// </summary> private static void ReadOffset(XmlReader r, IDictionary <string, OffsetType> offsets) { string offsetID = r.GetAttribute("offsetTypeID"); if (String.IsNullOrEmpty(offsetID)) { return; } if (!offsets.ContainsKey(offsetID)) { return; } OffsetType offset = offsets[offsetID]; offset.Unit = Unit.Unknown; while (r.Read()) { if (r.NodeType == XmlNodeType.Element) { if (r.Name == "offsetDescription") { r.Read(); offset.Description = r.Value; } else if (r.Name == "unitName") { r.Read(); offset.Unit.Name = r.Value; } else if (r.Name == "unitType") { r.Read(); offset.Unit.UnitsType = r.Value; } else if (r.Name == "unitAbbreviation") { r.Read(); offset.Unit.Abbreviation = r.Value; } } else if (r.NodeType == XmlNodeType.EndElement && r.Name == "offset") { return; } } }
private long?GetOffsetTypeID(DbConnection conn, OffsetType offsetType) { const string sqlOffsetType = "SELECT OffsetTypeID FROM OffsetTypes WHERE OffsetDescription = ?"; using (var cmd = conn.CreateCommand()) { cmd.CommandText = sqlOffsetType; cmd.Parameters.Add(_db.CreateParameter(DbType.String, offsetType.Description)); var result = cmd.ExecuteScalar(); if (result != null) { return(Convert.ToInt64(result)); } return(null); } }
public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, OrderType pType = OrderType.Limit, int pCustom = 0, HedgeType pHedge = HedgeType.Speculation) { InstrumentField dif; ExchangeStatusType es; //小节收盘:等待重新开盘 if (DicInstrumentField.TryGetValue(pInstrument, out dif)) { if (_initFlow) { pPrice += _floConfig.FirstAddTicks * (pDirection == DirectionType.Buy ? 1 : -1) * dif.PriceTick; } //限定在涨跌板范围内 MarketData f; if (_q == null) { ShowInfo("行情接口异常"); return(-1); } if (!_q.DicTick.TryGetValue(pInstrument, out f)) { _q.ReqSubscribeMarketData(pInstrument); Thread.Sleep(200); } if (_q.DicTick.TryGetValue(pInstrument, out f)) { ShowInfo($"合约{pInstrument}无行情"); } else { pPrice = Math.Max(f.LowerLimitPrice, Math.Min(f.UpperLimitPrice, pPrice)); } //下单前修正价格为最小变动的倍数 pPrice = (int)(pPrice / dif.PriceTick) * dif.PriceTick; if (DicExcStatus.TryGetValue(dif.ProductID, out es) || DicExcStatus.TryGetValue(dif.InstrumentID, out es) || DicExcStatus.TryGetValue(dif.ExchangeID.ToString(), out es)) { if (es == ExchangeStatusType.NoTrading) //小节收盘中:待处理 { ShowInfo($"小节收盘,待重新开盘后再发委托:{pInstrument},{pDirection},{ pOffset},{ pPrice},{ pVolume},{pCustom}"); _listWaitTrading.Add(new object[] { pInstrument, pDirection, pOffset, pPrice, pVolume, pType, pCustom, pHedge }); return(0); } } } return(base.ReqOrderInsert(pInstrument, pDirection, pOffset, pPrice, pVolume, pCustom, pType, pHedge)); }
public override void Read(PackFileDeserializer des, BinaryReaderEx br) { base.Read(des, br); m_child = des.ReadClassPointer <hkbGenerator>(br); m_offsetType = (OffsetType)br.ReadInt32(); m_taeId = br.ReadInt32(); m_valIndex = br.ReadInt32(); m_valRate = br.ReadSingle(); m_enableTae = br.ReadBoolean(); br.ReadUInt64(); br.ReadUInt64(); br.ReadUInt64(); br.ReadUInt64(); br.ReadUInt32(); br.ReadUInt16(); br.ReadByte(); }
public MemoryOffset(string inputString) { var split = inputString.Split('|'); Description = split[0]; MemoryOffsetAddress = Convert.ToInt64(split[1], 16); OffsetType t; if (Enum.TryParse(split[2], out t)) { OffsetType = t; } else { OffsetType = OffsetType.IntPointer; } }
private static int GetOffsetTypeId(OffsetType type) { switch (type) { case OffsetType.Subscript: return(0); case OffsetType.Regular: return(1); case OffsetType.Superscript: return(2); default: throw new ArgumentOutOfRangeException(); } }
public static Vector2 AxialToWorld(Axial axial, float pointRadius, OffsetType type) { float x; float y; if (type == OffsetType.EvenR || type == OffsetType.OddR) { x = pointRadius * Mathf.Sqrt( 3 ) * (axial.q + axial.r / 2); y = pointRadius * 3 / 2 * axial.r; } else { x = pointRadius * 3 / 2 * axial.q; y = pointRadius * Mathf.Sqrt( 3 ) * (axial.r + axial.q / 2); } return new Vector2( x, y ); }
private Vector3 GetOffsetMask(float offset, OffsetType type) { Vector3 offsetMask = Vector3.zero; if (type == OffsetType.Width) { offsetMask = new Vector3(offset, _etalonPosition.y, _etalonPosition.z); } else if (type == OffsetType.Height) { offsetMask = new Vector3(_etalonPosition.x, offset, _etalonPosition.z); } else if (type == OffsetType.Depth) { offsetMask = new Vector3(_etalonPosition.x, _etalonPosition.y, offset); } return(offsetMask); }
private void PopulateOffsetSetting() { // Populate combos on first pass if (cboWCS.Items.Count == 0) { var offsets = OffsetType.GetAllGCodeIdentifiers(true); var wcsList = from o in offsets where o.Category == OffsetType.Categories.WorkingCoordinateSystem select o; cboWCS.Items.AddRange(wcsList.ToArray()); var toolOffsetList = from o in offsets where o.Category == OffsetType.Categories.ToolHead select o; cboToolOffsets.Items.AddRange(toolOffsetList.ToArray()); } // Select active Working Coordinate System foreach (var i in cboWCS.Items) { if (((OffsetType)i).GCodeIdentifier == _settings.ActiveWorkingCoordinateSystem) { cboWCS.SelectedItem = i; } } // Select active Tool offset foreach (var i in cboToolOffsets.Items) { if (((OffsetType)i).GCodeIdentifier == _settings.ActiveToolOffset) { cboToolOffsets.SelectedItem = i; } } chkToolLengthOffset.Checked = _settings.ToolLengthOffsetActive; SetMachineWorkingOffset(); }
public void Offset(OffsetType type, double offsetX, double offsetY) { switch (type) { case OffsetType.TopLeft: OffsetTopLeft(offsetX, offsetY); break; case OffsetType.TopRight: OffsetTopRight(offsetX, offsetY); break; case OffsetType.BottomRight: OffsetBottomRight(offsetX, offsetY); break; case OffsetType.BottomLeft: OffsetBottomLeft(offsetX, offsetY); break; case OffsetType.Move: OffsetMove(offsetX, offsetY); break; } }
/// <summary> /// Edit vector3 value to a specific range, base on offset type. /// </summary> /// <param name="vector3"></param> /// <param name="offsetType"></param> /// <returns></returns> /// <exception cref="ArgumentException"></exception> static Vector3 Polish(Vector3 vector3, OffsetType offsetType) { // if (vector3.IsZero) return Vector3.Zero; float GetPosDimOffset(float p) => p >= 0 ? Math.Min(p, MaxPositionOffset) : Math.Max(p, -MaxPositionOffset); float GetRotDimOffset(float r) => r >= 0 ? Math.Min(r, MaxRotationOffset) : Math.Max(r, -MaxRotationOffset); switch (offsetType) { case OffsetType.Position: return(new Vector3(GetPosDimOffset(vector3.X), GetPosDimOffset(vector3.Y), GetPosDimOffset(vector3.Z))); case OffsetType.Rotation: return(new Vector3(GetRotDimOffset(vector3.X), GetRotDimOffset(vector3.Y), GetRotDimOffset(vector3.Z))); default: throw new ArgumentException(); } }
public Offset GetOffset(string value, OffsetType defaultType) { if (string.IsNullOrWhiteSpace(value)) { return(Offset.Empty); } value = value.Trim(); if (double.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, out var d)) { return(new Offset(d, defaultType)); } if (TryExtractOffset(value, out var res)) { return(res); } throw new InvalidOperationException($"Cannot convert \"{value}\" into {typeof(Offset)}"); }
public virtual void AttachSprite(GameElementSprite sprite, OffsetType _offsetType) { elementSprite = sprite; if (elementSprite.spriteRenderer == null) { elementSprite.spriteRenderer = elementSprite.gameObject.GetComponentInChildren <SpriteRenderer>(); } elementSprite.gameObject.transform.parent = this.transform; elementSprite.gameObject.transform.localPosition = Vector3.zero; elementSprite.gameObject.transform.localRotation = Quaternion.identity; if (_offsetType == OffsetType.BOTTOM_CENTER) { elementSprite.spriteRenderer.transform.localPosition = new Vector3(0f, elementSprite.spriteRenderer.size.y * 0.5f, 0f); } Debugger.Log("sprite attached: " + elementSprite.gameObject.name + " " + elementSprite.spriteRenderer.size); }
/// <summary> /// Read the vertical offset type /// </summary> private void ReadOffset(XmlReader r, Dictionary <string, OffsetType> offsets) { string offsetID = r.GetAttribute("offsetTypeID"); if (String.IsNullOrEmpty(offsetID)) { return; } if (!offsets.ContainsKey(offsetID)) { return; } OffsetType offset = offsets[offsetID]; while (r.Read()) { if (r.NodeType == XmlNodeType.Element) { if (r.Name == "offsetDescription") { r.Read(); offset.Description = r.Value; } else if (r.Name == "units") { Unit units = new Unit(); units.Abbreviation = r.GetAttribute("unitsAbbreviation"); r.Read(); units.Name = r.Value; offset.Unit = units; } } else if (r.NodeType == XmlNodeType.EndElement && r.Name == "offset") { return; } } }
private void PopulateWorkspaceOffsets() { // First, populate the list of GCode Identifiers if it isn't already loaded if (listBoxGCodeIdentifiers.Items.Count == 0) { listBoxGCodeIdentifiers.Items.AddRange(OffsetType.GetAllGCodeIdentifiers().ToArray()); listBoxGCodeIdentifiers.SelectedIndex = 0; } // Next, populate the offsets based on the selected GCode Identifier listBoxOffsets.Items.Clear(); var selectedOffsetType = listBoxGCodeIdentifiers.SelectedItem as OffsetType; if (selectedOffsetType != null) { var filteredOffsetList = from o in _machine.Settings.WorkspaceOffsets where o.Type.GCodeIdentifier == selectedOffsetType.GCodeIdentifier select o; listBoxOffsets.Items.AddRange(filteredOffsetList.ToArray()); _suppressEvent = true; // Prevent chain reactions for (int i = 0; i < listBoxOffsets.Items.Count; i++) { if (((WorkspaceOffset)listBoxOffsets.Items[i]).Active) { listBoxOffsets.SetItemCheckState(i, CheckState.Checked); } } _suppressEvent = false; if (listBoxOffsets.Items.Count > 0) { listBoxOffsets.SelectedIndex = 0; } } PopulateCurrentWorkplaceOffset(); }
public static int OffsetDistance(Offset a, Offset b, OffsetType type) { Cube ac = OffsetToCube(a, type); Cube bc = OffsetToCube(b, type); return CubeDistance(ac, bc); }
public MemoryOffset(string description, long memoryOffset, OffsetType offsetType) { Description = description; MemoryOffsetAddress = memoryOffset; OffsetType = offsetType; }
/// <summary> /// 委托 /// </summary> /// <param name="pInstrument">合约</param> /// <param name="pDirection">买卖</param> /// <param name="pOffset">开平</param> /// <param name="pPrice">价格</param> /// <param name="pVolume">数量</param> /// <param name="pType">委托类型</param> /// <param name="pCustom">自定义字段(6位数字)</param> /// <param name="pHedge">投保</param> /// <returns></returns> public abstract int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, int pCustom, OrderType pType = OrderType.Limit, HedgeType pHedge = HedgeType.Speculation);
public static Vector2 getClosestCollisionPoint(Vector2 pivot, Vector2 lineAStart, Vector2 lineAEnd, List<Vector2> v, float offset = float.NaN, OffsetType offsetType = OffsetType.round) { var list = new List<Vector2>() { lineAStart, lineAEnd, new Vector2(lineAEnd.X + 1, lineAEnd.Y + 1) }; return getClosestCollisionPoint(pivot, list, v, offset, offsetType); }
//COLLISIONTYPE COLLISION public static Vector2 getClosestCollisionPoint(Vector2 pivot, CollisionType collisionType1, CollisionType collisionType2, float offset = float.NaN, OffsetType offsetType = OffsetType.round) { PolygonSet p1; if (collisionType1 == CollisionType.unitCollision) { p1 = PremadePolygonSets.unitCollision; } else if (collisionType1 == CollisionType.visionCollision) { p1 = PremadePolygonSets.visionCollision; } else if (collisionType1 == CollisionType.bushCollision) { p1 = PremadePolygonSets.bushCollision; } else { return new Vector2(float.NaN, float.NaN); } PolygonSet p2; if (collisionType2 == CollisionType.unitCollision) { p2 = PremadePolygonSets.unitCollision; } else if (collisionType2 == CollisionType.visionCollision) { p2 = PremadePolygonSets.visionCollision; } else if (collisionType2 == CollisionType.bushCollision) { p2 = PremadePolygonSets.bushCollision; } else { return new Vector2(float.NaN, float.NaN); } return getCollisionPointClosest(p1, p2, pivot); }
/// <summary> /// Returns the position in the nodes stream of the next node. /// </summary> /// <param name="reader">Reader with exclusive access to the underlying file</param> /// <param name="childIndex"></param> /// <param name="numberOfChildren"></param> /// <param name="offsetType"></param> /// <returns></returns> private void SetNextNodePosition(BinaryReader reader, byte childIndex, byte numberOfChildren, OffsetType offsetType) { if (childIndex == 0) { // Move past the children offset to the first child. reader.BaseStream.Position += (numberOfChildren - 1) * SizeOfOffsets(offsetType); } else { // Move to the bytes that represent the node position of the next node based on the child index. reader.BaseStream.Position += (childIndex - 1) * SizeOfOffsets(offsetType); switch (offsetType) { case OffsetType.Bits16: reader.BaseStream.Position += reader.ReadUInt16(); break; case OffsetType.Bits32: reader.BaseStream.Position += reader.ReadUInt32(); break; default: reader.BaseStream.Position += reader.ReadInt64(); break; } } }
/// <summary> /// Method to generate a list of offset (from OD OffsetTypes table) in a ValuesDataSet /// This is done as a separate method since Values can could contain other VariableValue Types /// /// </summary> /// <param name="ds">ValuesDataSet with the values used in the timeSeries</param> /// <returns></returns> public static List <OffsetType> datasetOffsetTypes(ValuesDataSet ds) { /* generate a list * create a distinct DataSet * - new data view * - set filter (no nulls) * - use toTable with unique to get unique list * foreach to generate qualifiers * */ string COLUMN = "OffsetTypeID"; string TABLENAME = "offsetTypes"; List <OffsetType> list = new List <OffsetType>(); try { DataView view = new DataView(ds.DataValues); view.RowFilter = COLUMN + " is not Null"; DataTable ids = view.ToTable(TABLENAME, true, new string[] { COLUMN }); foreach (DataRow r in ids.Rows) { try { Object aId = r[COLUMN]; // edit here ValuesDataSet.OffsetTypesRow offset = ds.OffsetTypes.FindByOffsetTypeID((int)aId); if (offset != null) { OffsetType t = new OffsetType(); t.offsetTypeID = offset.OffsetTypeID; t.offsetTypeIDSpecified = true; if (!String.IsNullOrEmpty(offset.OffsetDescription)) { t.offsetDescription = offset.OffsetDescription; } ValuesDataSet.UnitsRow offUnit = ds.Units.FindByUnitsID(offset.OffsetUnitsID); string offUnitsCode; string offUnitsName = null; string offUnitsAbbreviation = null; if (!String.IsNullOrEmpty(offUnit.UnitsAbbreviation)) { offUnitsAbbreviation = offUnit.UnitsAbbreviation; } if (!String.IsNullOrEmpty(offUnit.UnitsName)) { offUnitsName = offUnit.UnitsName; } if (offUnit != null) { t.units = CuahsiBuilder.CreateUnitsElement( null, offUnit.UnitsID.ToString(), offUnitsAbbreviation, offUnitsName); } list.Add(t); } } catch (Exception e) { log.Error("Error generating a qualifier " + r.ToString() + e.Message); } } return(list); } catch (Exception e) { log.Error("Error generating a qualifiers " + e.Message); // non fatal exceptions return(null); } }
public static Cube RoundWorldToCube(Vector2 point, float pointRadius, OffsetType type) { return CubeRound( AxialToCube( WorldToAxial( point, pointRadius, type ) ) ); }
protected void OnElementMovedAction(OffsetType type, Rect rect) { if (null != ElementMovedAction) { ElementMovedAction(_element, rect); } }
static extern bool gimp_drawable_offset(Int32 drawable_ID, bool wrap_around, OffsetType fill_type, int offset_x, int offset_y);
public void Offset(bool wrapAround, OffsetType fillType, Offset offset) { Offset(wrapAround, fillType, offset.X, offset.Y); }
public void Offset(bool wrapAround, OffsetType fillType, int offsetX, int offsetY) { if (!gimp_drawable_offset(ID, wrapAround, fillType, offsetX, offsetY)) { throw new GimpSharpException(); } }
public static AxialFraction WorldToAxial(Vector2 point, float pointRadius, OffsetType type) { float q; float r; // Pointy top if ( type == OffsetType.EvenR || type == OffsetType.OddR ) { q = ((point.x * (Mathf.Sqrt(3.0f) / 3.0f)) - (point.y / 3.0f)) / pointRadius; r = point.y * 2.0f/3.0f / pointRadius; } // Flat top else { q = point.x * 2.0f/3.0f / pointRadius; r = (-point.x / 3.0f + Mathf.Sqrt(3.0f) / 3.0f * point.y) / pointRadius; } return new AxialFraction(q, r); }
/// <summary> /// /// </summary> /// <param name="pInstrument"></param> /// <param name="pDirection"></param> /// <param name="pOffset"></param> /// <param name="pPrice">价格</param> /// <param name="pVolume"></param> /// <param name="pHedge"></param> /// <param name="pType">报单类型</param> /// <returns></returns> public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, HedgeType pHedge, OrderType pType, string pCustom) { return(((DefReqOrderInsert)Invoke(this._handle, "ReqOrderInsert", typeof(DefReqOrderInsert)))(pInstrument, pDirection, pOffset, pPrice, pVolume, pHedge, pType, pCustom)); }
public static Vector2 OffsetToWorld(Offset offset, float pointRadius, OffsetType type) { float x; float y; if (type == OffsetType.EvenQ) { x = pointRadius * 3.0f / 2.0f * offset.x; y = pointRadius * Mathf.Sqrt(3) * (offset.y - .5f * (offset.x % 2)); } else if (type == OffsetType.EvenR) { x = pointRadius * Mathf.Sqrt(3) * (offset.x - .5f * (offset.y % 2)); y = pointRadius * 3.0f / 2.0f * offset.y; } else if (type == OffsetType.OddQ) { x = pointRadius * 3.0f / 2.0f * offset.x; y = pointRadius * Mathf.Sqrt(3) * (offset.y + .5f * (offset.x % 2)); } //OddR else { x = pointRadius * Mathf.Sqrt(3) * (offset.x + .5f * (offset.y % 2)); y = pointRadius * 3.0f / 2.0f * offset.y; } return new Vector2(x, y); }
public override int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, int pCustom, OrderType pType = OrderType.Limit, HedgeType pHedge = HedgeType.Speculation) { //限价 var OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice; var TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_GFD; var VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_AV; if (pType == OrderType.Market) //市价 { OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_AnyPrice; TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC; //max = instField.MaxMarketOrderVolume; pPrice = 0; } else if (pType == OrderType.FAK) //FAK { OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice; TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC; } else if (pType == OrderType.FOK) //FOK { OrderPriceType = TThostFtdcOrderPriceTypeType.THOST_FTDC_OPT_LimitPrice; TimeCondition = TThostFtdcTimeConditionType.THOST_FTDC_TC_IOC; VolumeCondition = TThostFtdcVolumeConditionType.THOST_FTDC_VC_CV; //全部数量 } return((int)_t.ReqOrderInsert(_broker, _investor, InstrumentID: pInstrument, OrderRef: string.Format("{0:000000}{1:000000}", _ref++, pCustom % 1000000), CombHedgeFlag: new string((char)(pHedge == HedgeType.Speculation ? TThostFtdcHedgeFlagType.THOST_FTDC_HF_Speculation : pHedge == HedgeType.Arbitrage ? TThostFtdcHedgeFlagType.THOST_FTDC_HF_Arbitrage : TThostFtdcHedgeFlagType.THOST_FTDC_HF_Hedge), 1), CombOffsetFlag: new String((char)(pOffset == OffsetType.Open ? TThostFtdcOffsetFlagType.THOST_FTDC_OF_Open : pOffset == OffsetType.Close ? TThostFtdcOffsetFlagType.THOST_FTDC_OF_Close : TThostFtdcOffsetFlagType.THOST_FTDC_OF_CloseToday), 1), Direction: pDirection == DirectionType.Buy ? TThostFtdcDirectionType.THOST_FTDC_D_Buy : TThostFtdcDirectionType.THOST_FTDC_D_Sell, VolumeTotalOriginal: pVolume, ForceCloseReason: TThostFtdcForceCloseReasonType.THOST_FTDC_FCC_NotForceClose, ContingentCondition: TThostFtdcContingentConditionType.THOST_FTDC_CC_Immediately, VolumeCondition: VolumeCondition, LimitPrice: pPrice, IsSwapOrder: 0, MinVolume: 1, UserForceClose: 0, TimeCondition: TimeCondition, OrderPriceType: OrderPriceType)); }
public static Cube OffsetToCube( Offset offset, OffsetType type ) { Cube c; if (type == OffsetType.EvenQ) { c = EvenQToCube(offset); } else if (type == OffsetType.EvenR) { c = EvenRToCube(offset); } else if (type == OffsetType.OddQ) { c = OddQToCube(offset); } else { c = OddRToCube(offset); } return c; }
public static Vector2 getClosestCollisionPoint(Vector2 pivot, List<List<Vector2>> polygonSet1, List<List<Vector2>> polygonSet2, float offset = float.NaN, OffsetType offsetType = OffsetType.round) { PolygonSet p; if (offsetType == OffsetType.round) { p = Generate.offsetLineRound(PolygonHelperClass.VectorsToPolys(polygonSet1), offset); } else if (offsetType == OffsetType.square) { p = Generate.offsetLineSquare(PolygonHelperClass.VectorsToPolys(polygonSet1), offset); } else { return new Vector2(float.NaN, float.NaN); } return getCollisionPointClosest(p, PolygonHelperClass.VectorsToPolys(polygonSet2), pivot); }
/// <summary> /// Method to generate a list of offset (from OD OffsetTypes table) in a ValuesDataSet /// This is done as a separate method since Values can could contain other VariableValue Types /// /// </summary> /// <param name="ds">ValuesDataSet with the values used in the timeSeries</param> /// <returns></returns> public static List<OffsetType> datasetOffsetTypes(ValuesDataSet ds, string valuesWhereClause) { /* generate a list * create a distinct DataSet * - new data view * - set filter (no nulls) * - use toTable with unique to get unique list * foreach to generate qualifiers * */ string COLUMN = "OffsetTypeID"; string TABLENAME = "offsetTypes"; List<OffsetType> list = new List<OffsetType>(); try { DataView view = new DataView(ds.DataValues); view.RowFilter = valuesWhereClause; DataTable ids = view.ToTable(TABLENAME, true, new string[] {COLUMN}); foreach (DataRow r in ids.Rows) { try { //Object aId = r[COLUMN]; if (r[COLUMN] == DBNull.Value) { continue; } int? aId = Convert.ToInt32(r[COLUMN]); // edit here ValuesDataSet.OffsetTypesRow offset = ds.OffsetTypes.FindByOffsetTypeID((int) aId.Value); if (offset != null) { OffsetType t = new OffsetType(); t.offsetTypeID = offset.OffsetTypeID; t.offsetTypeIDSpecified = true; t.offsetTypeCode = t.offsetTypeID.ToString(); if (!String.IsNullOrEmpty(offset.OffsetDescription)) t.offsetDescription = offset.OffsetDescription; ValuesDataSet.UnitsRow offUnit = ds.Units.FindByUnitsID(offset.OffsetUnitsID); string offUnitsCode; string offUnitsName = null; string offUnitsAbbreviation = null; if (!String.IsNullOrEmpty(offUnit.UnitsAbbreviation)) offUnitsAbbreviation = offUnit.UnitsAbbreviation; if (!String.IsNullOrEmpty(offUnit.UnitsName)) offUnitsName = offUnit.UnitsName; if (offUnit != null) t.unit = CuahsiBuilder.CreateUnitsElement( offUnit.UnitsType, offUnit.UnitsID.ToString(), offUnitsAbbreviation, offUnitsName); list.Add(t); } } catch (Exception e) { log.Error("Error generating a offsetTypes " + r.ToString() + e.Message); } } return list; } catch (Exception e) { log.Error("Error generating a offsetTypes " + e.Message); // non fatal exceptions return null; } }
public static Vector2 getClosestCollisionPoint(Vector2 pivot, Vector2 point1, Vector2 point2, float offset = float.NaN, OffsetType offsetType = OffsetType.round) { var list = new List<Vector2>() { point1, new Vector2(point1.X + 1, point1.Y + 1), new Vector2(point1.X - 1, point1.Y + 1) }; return getClosestCollisionPoint(pivot, point2, list, offset, offsetType); }
public static Offset OffsetRound(Vector2 point, float pointRadius, OffsetType type) { if (type == OffsetType.EvenQ) return HexMath.CubeToEvenQ(HexMath.CubeRound(HexMath.AxialToCube(HexMath.WorldToAxial(new Vector2(point.x, point.y), .5f, type)))); else if (type == OffsetType.EvenR) return HexMath.CubeToEvenR(HexMath.CubeRound(HexMath.AxialToCube(HexMath.WorldToAxial(new Vector2(point.x, point.y), .5f, type)))); else if (type == OffsetType.OddQ) return HexMath.CubeToOddQ(HexMath.CubeRound(HexMath.AxialToCube(HexMath.WorldToAxial(new Vector2(point.x, point.y), .5f, type)))); else return HexMath.CubeToOddR(HexMath.CubeRound(HexMath.AxialToCube(HexMath.WorldToAxial(new Vector2(point.x, point.y), .5f, type)))); }
public static Vector2 getClosestCollisionPoint(Vector2 pivot, Vector2 lineAStart, Vector2 lineAEnd, Vector2 lineBStart, Vector2 lineBEnd, float offset = float.NaN, OffsetType offsetType = OffsetType.round) { PolygonSet p = new PolygonSet(); var list = new List<IntPoint>() { new IntPoint(lineBStart.X, lineBStart.Y), new IntPoint(lineBEnd.X, lineBEnd.Y), new IntPoint(lineBEnd.X + 1, lineBEnd.Y + 1) }; if (offsetType == OffsetType.round) { p = Generate.offsetLineRound(list, offset); } else if (offsetType == OffsetType.square) { p = Generate.offsetLineSquare(list, offset); } else { return new Vector2(float.NaN, float.NaN); } return getClosestCollisionPoint(pivot, lineAStart, lineAEnd, offset, offsetType); }
/// <summary> /// /// </summary> /// <param name="pInstrument"></param> /// <param name="pDirection"></param> /// <param name="pOffset"></param> /// <param name="pPrice"></param> /// <param name="pVolume"></param> /// <param name="pHedge"></param> /// <returns>正确返回0</returns> public int ReqOrderInsert(string pInstrument, DirectionType pDirection, OffsetType pOffset, double pPrice, int pVolume, HedgeType pHedge = HedgeType.Speculation, OrderType pType = OrderType.Limit) { return _proxy.ReqOrderInsert(pInstrument, pDirection, pOffset, pPrice, pVolume, pHedge, pType); }
public MemoryOffset(string description, string memoryOffset, OffsetType offsetType) { Description = description; MemoryOffsetAddress = Convert.ToInt64(memoryOffset, 16); OffsetType = offsetType; }
internal ExternalOffset(int offset, OffsetType offsetType) : this(None, offset, offsetType) { }
public static Offset OffsetNeighbor(Offset start, int direction, OffsetType type) { Cube startc = OffsetToCube(start, type); Cube neighbor = CubeNeighber(startc, direction); return CubeToOffset(neighbor, type); }
/// <summary> /// Main /// </summary> internal ExternalOffset(ExternalOffset dependency, int offset, OffsetType offsetType) { Dependency = dependency; Offset = offset; OffsetType = offsetType; }
public static UserType ParseType(XElement xmlType, Dictionary <string, IType> scopedTypes) { var typeName = xmlType.Attribute("name"); var type = new UserType(typeName.Value); var subTypes = xmlType.Elements("type"); var attributes = xmlType.Elements("attr"); scopedTypes.Add(type.Name, type); foreach (var subType in subTypes) { var parsed = ParseType(subType, new Dictionary <string, IType>(scopedTypes)); scopedTypes.Add(parsed.Name, parsed); } foreach (var attr in attributes) { var attrName = attr.Attribute("name"); var typeAttr = attr.Attribute("type"); var typeExpr = attr.Element("type"); var offsetExpr = attr.Element("offset"); var sizeExpr = attr.Element("size"); var conditionExpr = attr.Element("if"); var repeatType = attr.Element("repeat"); IPotential <IType> typePotential; if (typeAttr != null || typeExpr != null) { IPotential <string> namePotential = typeAttr != null ? (IPotential <string>) new TrivialPotential <string>(typeAttr.Value) : (IPotential <string>) new Expression <string>(typeExpr.Value); typePotential = new NamedTypePotential(scopedTypes, namePotential); } else { typePotential = new TrivialPotential <IType>(new VoidType(new Expression <long>(sizeExpr.Value))); } if (offsetExpr != null) { var baseType = typePotential; var offsetType = new OffsetType(baseType, new Expression <long>(offsetExpr.Value)); typePotential = new TrivialPotential <IType>(offsetType); } if (conditionExpr != null) { var baseType = typePotential; var conditionalType = new ConditionalType(baseType, new Expression <bool>(conditionExpr.Value)); typePotential = new TrivialPotential <IType>(conditionalType); } if (repeatType != null) { var lengthExpr = attr.Element("repeat-expr"); var untilExpr = attr.Element("repeat-until"); var baseType = typePotential; if (repeatType.Value == "expr") { var arrayType = new DefiniteArrayType(baseType, new Expression <int>(lengthExpr.Value)); typePotential = new TrivialPotential <IType>(arrayType); } else if (repeatType.Value == "until") { var arrayType = new IndefiniteArrayType(baseType, new Expression <bool>(untilExpr.Value)); typePotential = new TrivialPotential <IType>(arrayType); } } type.Attributes.Add(attrName.Value, typePotential); } return(type); }
//------------------------------------------------- private void CreateAndAddButtonInfo(EVRButtonId buttonID) { Transform buttonTransform = null; List <MeshRenderer> buttonRenderers = new List <MeshRenderer>(); string buttonDebug = "Looking for button: " + buttonID; EVRButtonId searchButtonID = buttonID; if (buttonID == EVRButtonId.k_EButton_Grip && SteamVR.instance.hmd_TrackingSystemName.ToLowerInvariant().Contains("oculus")) { searchButtonID = EVRButtonId.k_EButton_Axis2; } ulong buttonMaskForID = (1ul << (int)searchButtonID); foreach (KeyValuePair <string, ulong> componentButtonMask in componentButtonMasks) { if ((componentButtonMask.Value & buttonMaskForID) == buttonMaskForID) { buttonDebug += "\nFound component: " + componentButtonMask.Key + " " + componentButtonMask.Value; Transform componentTransform = renderModel.FindComponent(componentButtonMask.Key); buttonTransform = componentTransform; buttonDebug += "\nFound componentTransform: " + componentTransform + " buttonTransform: " + buttonTransform; buttonRenderers.AddRange(componentTransform.GetComponentsInChildren <MeshRenderer>()); } } buttonDebug += "\nFound " + buttonRenderers.Count + " renderers for " + buttonID; foreach (MeshRenderer renderer in buttonRenderers) { buttonDebug += "\n\t" + renderer.name; } HintDebugLog(buttonDebug); if (buttonTransform == null) { HintDebugLog("Couldn't find buttonTransform for " + buttonID); return; } ButtonHintInfo hintInfo = new ButtonHintInfo(); buttonHintInfos.Add(buttonID, hintInfo); hintInfo.componentName = buttonTransform.name; hintInfo.renderers = buttonRenderers; //Get the local transform for the button hintInfo.localTransform = buttonTransform.Find(SteamVR_RenderModel.k_localTransformName); OffsetType offsetType = OffsetType.Right; switch (buttonID) { case EVRButtonId.k_EButton_SteamVR_Trigger: { offsetType = OffsetType.Right; } break; case EVRButtonId.k_EButton_ApplicationMenu: { offsetType = OffsetType.Right; } break; case EVRButtonId.k_EButton_System: { offsetType = OffsetType.Right; } break; case Valve.VR.EVRButtonId.k_EButton_Grip: { offsetType = OffsetType.Forward; } break; case Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad: { offsetType = OffsetType.Up; } break; } //Offset for the text end transform switch (offsetType) { case OffsetType.Forward: hintInfo.textEndOffsetDir = hintInfo.localTransform.forward; break; case OffsetType.Back: hintInfo.textEndOffsetDir = -hintInfo.localTransform.forward; break; case OffsetType.Right: hintInfo.textEndOffsetDir = hintInfo.localTransform.right; break; case OffsetType.Up: hintInfo.textEndOffsetDir = hintInfo.localTransform.up; break; } //Create the text hint object Vector3 hintStartPos = hintInfo.localTransform.position + (hintInfo.localTransform.forward * 0.01f); hintInfo.textHintObject = GameObject.Instantiate(textHintPrefab, hintStartPos, Quaternion.identity) as GameObject; hintInfo.textHintObject.name = "Hint_" + hintInfo.componentName + "_Start"; hintInfo.textHintObject.transform.SetParent(textHintParent); hintInfo.textHintObject.layer = gameObject.layer; hintInfo.textHintObject.tag = gameObject.tag; //Get all the relevant child objects hintInfo.textStartAnchor = hintInfo.textHintObject.transform.Find("Start"); hintInfo.textEndAnchor = hintInfo.textHintObject.transform.Find("End"); hintInfo.canvasOffset = hintInfo.textHintObject.transform.Find("CanvasOffset"); hintInfo.line = hintInfo.textHintObject.transform.Find("Line").GetComponent <LineRenderer>(); hintInfo.textCanvas = hintInfo.textHintObject.GetComponentInChildren <Canvas>(); hintInfo.text = hintInfo.textCanvas.GetComponentInChildren <Text>(); hintInfo.textMesh = hintInfo.textCanvas.GetComponentInChildren <TextMesh>(); hintInfo.textHintObject.SetActive(false); hintInfo.textStartAnchor.position = hintStartPos; if (hintInfo.text != null) { hintInfo.text.text = hintInfo.componentName; } if (hintInfo.textMesh != null) { hintInfo.textMesh.text = hintInfo.componentName; } centerPosition += hintInfo.textStartAnchor.position; // Scale hint components to match player size hintInfo.textCanvas.transform.localScale = Vector3.Scale(hintInfo.textCanvas.transform.localScale, player.transform.localScale); hintInfo.textStartAnchor.transform.localScale = Vector3.Scale(hintInfo.textStartAnchor.transform.localScale, player.transform.localScale); hintInfo.textEndAnchor.transform.localScale = Vector3.Scale(hintInfo.textEndAnchor.transform.localScale, player.transform.localScale); hintInfo.line.transform.localScale = Vector3.Scale(hintInfo.line.transform.localScale, player.transform.localScale); }
public void UpdateOffset(OffsetType type, double value) { }
public static RadialGradient At(this RadialGradient gradient, double x, double y, OffsetType type = OffsetType.Proportional) { return(gradient.At(new Position(x, y, type))); }
public static List<Offset> GetOffsetsInRange(Offset center, int range, OffsetType type) { List<Offset> offsets = new List<Offset>(); List<Cube> cubes = GetCubesInRange(OffsetToCube(center, type), range); for (int i = 0; i < cubes.Count; i++) offsets.Add(CubeToOffset(cubes[i], type)); return offsets; }
public static RadialGradient Size(this RadialGradient gradient, double width, double height, OffsetType type = OffsetType.Absolute) { return(gradient.Size(new Dimensions(width, height, type))); }
public static List<Offset> GetOffsetsInLine(Offset a, Offset b, OffsetType type) { Cube ac = OffsetToCube(a, type); Cube bc = OffsetToCube(b, type); List<Cube> cubeList = GetCubesInLine(ac, bc); List<Offset> offsetList = new List<Offset>(); foreach ( Cube cube in cubeList ) offsetList.Add(CubeToOffset(cube, type)); return offsetList; }
//POLYGOTSET COLLISION public static Vector2 getClosestCollisionPoint(Vector2 pivot, List<List<Vector2>> polygonSet1, CollisionType collisionType, float offset = float.NaN, OffsetType offsetType = OffsetType.round) { PolygonSet p; if (offsetType == OffsetType.round) { p = Generate.offsetLineRound(PolygonHelperClass.VectorsToPolys(polygonSet1), offset); } else if (offsetType == OffsetType.square) { p = Generate.offsetLineSquare(PolygonHelperClass.VectorsToPolys(polygonSet1), offset); } else { return new Vector2(float.NaN, float.NaN); } PolygonSet p2; if (collisionType == CollisionType.unitCollision) { p2 = PremadePolygonSets.unitCollision; } else if (collisionType == CollisionType.visionCollision) { p2 = PremadePolygonSets.visionCollision; } else if (collisionType == CollisionType.bushCollision) { p2 = PremadePolygonSets.bushCollision; } else { return new Vector2(float.NaN, float.NaN); } return getCollisionPointClosest(p, p2, pivot); }
//------------------------------------------------- private void CreateAndAddButtonInfo(ISteamVR_Action_In action, SteamVR_Input_Sources inputSource) { Transform buttonTransform = null; List <MeshRenderer> buttonRenderers = new List <MeshRenderer>(); StringBuilder buttonDebug = new StringBuilder(); buttonDebug.Append("Looking for action: "); buttonDebug.AppendLine(action.GetShortName()); buttonDebug.Append("Action localized origin: "); buttonDebug.AppendLine(action.GetLocalizedOrigin(inputSource)); string actionComponentName = action.GetRenderModelComponentName(inputSource); if (componentTransformMap.ContainsKey(actionComponentName)) { buttonDebug.AppendLine(string.Format("Found component: {0} for {1}", actionComponentName, action.GetShortName())); Transform componentTransform = componentTransformMap[actionComponentName]; buttonTransform = componentTransform; buttonDebug.AppendLine(string.Format("Found componentTransform: {0}. buttonTransform: {1}", componentTransform, buttonTransform)); buttonRenderers.AddRange(componentTransform.GetComponentsInChildren <MeshRenderer>()); } else { buttonDebug.AppendLine(string.Format("Can't find component transform for action: {0}. Component name: \"{1}\"", action.GetShortName(), actionComponentName)); } buttonDebug.AppendLine(string.Format("Found {0} renderers for {1}", buttonRenderers.Count, action.GetShortName())); foreach (MeshRenderer renderer in buttonRenderers) { buttonDebug.Append("\t"); buttonDebug.AppendLine(renderer.name); } HintDebugLog(buttonDebug.ToString()); if (buttonTransform == null) { HintDebugLog("Couldn't find buttonTransform for " + action.GetShortName()); return; } ActionHintInfo hintInfo = new ActionHintInfo(); actionHintInfos.Add(action, hintInfo); hintInfo.componentName = buttonTransform.name; hintInfo.renderers = buttonRenderers; //Get the local transform for the button for (int childIndex = 0; childIndex < buttonTransform.childCount; childIndex++) { Transform child = buttonTransform.GetChild(childIndex); if (child.name == SteamVR_RenderModel.k_localTransformName) { hintInfo.localTransform = child; } } OffsetType offsetType = OffsetType.Right; /* * switch ( buttonID ) * { * case EVRButtonId.k_EButton_SteamVR_Trigger: * { * offsetType = OffsetType.Right; * } * break; * case EVRButtonId.k_EButton_ApplicationMenu: * { * offsetType = OffsetType.Right; * } * break; * case EVRButtonId.k_EButton_System: * { * offsetType = OffsetType.Right; * } * break; * case Valve.VR.EVRButtonId.k_EButton_Grip: * { * offsetType = OffsetType.Forward; * } * break; * case Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad: * { * offsetType = OffsetType.Up; * } * break; * } */ //Offset for the text end transform switch (offsetType) { case OffsetType.Forward: hintInfo.textEndOffsetDir = hintInfo.localTransform.forward; break; case OffsetType.Back: hintInfo.textEndOffsetDir = -hintInfo.localTransform.forward; break; case OffsetType.Right: hintInfo.textEndOffsetDir = hintInfo.localTransform.right; break; case OffsetType.Up: hintInfo.textEndOffsetDir = hintInfo.localTransform.up; break; } //Create the text hint object Vector3 hintStartPos = hintInfo.localTransform.position + (hintInfo.localTransform.forward * 0.01f); hintInfo.textHintObject = GameObject.Instantiate(textHintPrefab, hintStartPos, Quaternion.identity) as GameObject; hintInfo.textHintObject.name = "Hint_" + hintInfo.componentName + "_Start"; hintInfo.textHintObject.transform.SetParent(textHintParent); hintInfo.textHintObject.layer = gameObject.layer; hintInfo.textHintObject.tag = gameObject.tag; //Get all the relevant child objects hintInfo.textStartAnchor = hintInfo.textHintObject.transform.Find("Start"); hintInfo.textEndAnchor = hintInfo.textHintObject.transform.Find("End"); hintInfo.canvasOffset = hintInfo.textHintObject.transform.Find("CanvasOffset"); hintInfo.line = hintInfo.textHintObject.transform.Find("Line").GetComponent <LineRenderer>(); hintInfo.textCanvas = hintInfo.textHintObject.GetComponentInChildren <Canvas>(); hintInfo.text = hintInfo.textCanvas.GetComponentInChildren <Text>(); hintInfo.textMesh = hintInfo.textCanvas.GetComponentInChildren <TextMesh>(); hintInfo.textHintObject.SetActive(false); hintInfo.textStartAnchor.position = hintStartPos; if (hintInfo.text != null) { hintInfo.text.text = hintInfo.componentName; } if (hintInfo.textMesh != null) { hintInfo.textMesh.text = hintInfo.componentName; } centerPosition += hintInfo.textStartAnchor.position; // Scale hint components to match player size hintInfo.textCanvas.transform.localScale = Vector3.Scale(hintInfo.textCanvas.transform.localScale, player.transform.localScale); hintInfo.textStartAnchor.transform.localScale = Vector3.Scale(hintInfo.textStartAnchor.transform.localScale, player.transform.localScale); hintInfo.textEndAnchor.transform.localScale = Vector3.Scale(hintInfo.textEndAnchor.transform.localScale, player.transform.localScale); hintInfo.line.transform.localScale = Vector3.Scale(hintInfo.line.transform.localScale, player.transform.localScale); }
/// <summary> /// The number of bytes each offset takes. /// </summary> /// <param name="offsetType"></param> /// <returns></returns> public static int SizeOfOffsets(OffsetType offsetType) { switch (offsetType) { case OffsetType.Bits16: return sizeof(ushort); case OffsetType.Bits32: return sizeof(uint); default: return sizeof(long); } }