private FeatureActivationAttribute CreateAttribute(FeatureTypes validLicense, FeatureTypes requiredLicense) { var featureLicenseHelperMock = new Mock <IFeatureLicenseHelper>(MockBehavior.Strict); featureLicenseHelperMock.Setup(i => i.GetValidBlueprintLicenseFeatures()).Returns(validLicense); return(new FeatureActivationAttribute(requiredLicense, featureLicenseHelperMock.Object)); }
// void CreateMapFeature(FeatureTypes featureType, MapCoor center) { string[] mapFeature; switch (featureType) { case (FeatureTypes.FOREST_CIRCLE): mapFeature = MapFeatures.forestCircle; break; default: mapFeature = MapFeatures.forestCircle; break; } MapCoor featureCenter = new MapCoor(mapFeature[0].Length / 2, mapFeature.Length / 2); for (int row = 0; row < mapFeature.Length; row++) { char[] rowOfChars = mapFeature[row].ToCharArray(); for (int col = 0; col < rowOfChars.Length; col += 3) { if (rowOfChars[col] == ' ') { SetTile(1, new MapCoor(center.x + col / 3, center.y + row), '\0'); } else { SetTile(1, new MapCoor(center.x + col / 3, center.y + row), rowOfChars[col]); } } } }
private string GetEncryptedLicense(FeatureTypes feature, DateTime expiration) { var license = new[] { new FeatureInformation(FeatureInformation.Features.Single(p => p.Value == feature).Key, expiration) }; var xml = SerializationHelper.ToXml(license); return(SystemEncryptions.Encrypt(xml)); }
public Follower(double x, double y, FeatureTypes featureType, int featureNumber) { X = x; Y = y; FeatureType = featureType; FeatureNumber = featureNumber; }
/// <summary> /// Initialises the new instance with the mesh to work with and the base instance to interact with PowerShape. /// The feature type to recognise is set to plane. /// </summary> /// <param name="mesh">The mesh to fit a surface to.</param> /// <remarks></remarks> public ManualFitSurfaceToMeshTool(PSMesh mesh) { _mesh = mesh; _powershape = mesh.PowerSHAPE; _trianglePicker = new PSMeshTrianglePicker(mesh); _featureTypeToRecognise = FeatureTypes.Plane; // Only chose this because Powershape defaults to Plane }
public static Feature CreateFeature(FeatureTypes type, IntVector2 worldPosition) { if (!Instance._features.TryGetValue(type, out var featureObject)) { _log.Error($"Could not find an object for featureType `{type}."); } featureObject = Instantiate(featureObject); featureObject.transform.position = worldPosition; var feature = featureObject.GetComponent <Feature>(); featureObject.name = feature.ObjectName; _log.ErrorIfNull(feature, $"Block of type {type} has not been given a 'feature' component."); return(feature); }
// void CreateMapFeature(FeatureCenterPair fcp) { FeatureTypes featureType = fcp.featureType; MapCoor center = fcp.center; string[] mapFeature = MapFeatures.GetFeature(featureType); int layer = 1; if (fcp.featureType == FeatureTypes.CASTLE) { layer = 2; } if (fcp.mirrored) { string[] copy = mapFeature; for (int i = 0; i < copy.Length; i++) { mapFeature[i] = new string(mapFeature[i].ToCharArray().Reverse().ToArray()); for (int j = 0; j < copy[0].Length; j += 3) { // mapFeature[i].ToCharArray()[j] = copy[i].ToCharArray()[copy[0].Length - j - 1]; } } } for (int row = 0; row < mapFeature.Length; row++) { char[] rowOfChars = mapFeature[row].ToCharArray(); for (int col = 0; col < rowOfChars.Length; col += 3) { if (rowOfChars[col] == ' ') { SetTile(layer, new MapCoor(center.x + col / 3, center.y + row), '\0'); } else { SetTile(layer, new MapCoor(center.x + col / 3, center.y + row), rowOfChars[col]); } } } }
public static string[] GetFeature(FeatureTypes featureType) { switch (featureType) { case (FeatureTypes.FOREST_CIRCLE): return(MapFeatures.forestCircle); case (FeatureTypes.DARK_FOREST): return(MapFeatures.darkForest); case (FeatureTypes.AIRSHIP_SALESMAN): return(MapFeatures.airshipSalesman); case (FeatureTypes.CASTLE): return(MapFeatures.castle); default: return(MapFeatures.forestCircle); } }
/// <summary> /// Updates PowerShape with the feature type to recognise. /// </summary> /// <param name="type">The feature type to recognise.</param> /// <remarks></remarks> private void RecogniseType(FeatureTypes type) { switch (type) { case FeatureTypes.Cone: _powershape.DoCommand("Primtype Cone"); break; case FeatureTypes.Cylinder: _powershape.DoCommand("Primtype Cylinder"); break; case FeatureTypes.Extrusion: _powershape.DoCommand("Primtype Extrusion"); break; case FeatureTypes.Plane: _powershape.DoCommand("Primtype Plane"); break; case FeatureTypes.RevolvedSurface: _powershape.DoCommand("Primtype Revolution"); break; case FeatureTypes.ShrinkWrap: _powershape.DoCommand("Primtype ShrinkWrap"); break; case FeatureTypes.Sphere: _powershape.DoCommand("Primtype Sphere"); break; case FeatureTypes.Tori: _powershape.DoCommand("Primtype Torus"); break; } }
/// <summary> /// This creates a new featureset by checking each row of the table. If the WKB feature /// type matches the specifeid featureTypes, then it will copy that. /// </summary> /// <param name="wkbTable"></param> /// <param name="wkbColumnIndex"></param> /// <param name="indexed"></param> /// <param name="type"></param> public FeatureSet(DataTable wkbTable, int wkbColumnIndex, bool indexed, FeatureTypes type) { if(_indexMode) { // Assume this DataTable has WKB in column[0] and the rest of the columns are attributes. FeatureSetPack result = new FeatureSetPack(); foreach (DataRow row in wkbTable.Rows) { byte[] data = (byte[])row[0]; MemoryStream ms = new MemoryStream(data); WkbFeatureReader.ReadFeature(ms, result); } // convert lists of arrays into a single vertex array for each shape type. result.StopEditing(); // Make sure all the same columns exist in the same order result.Polygons.CopyTableSchema(wkbTable); // Assume that all the features happend to be polygons foreach (DataRow row in wkbTable.Rows) { // Create a new row DataRow dest = result.Polygons.DataTable.NewRow(); // dest.ItemArray = row.ItemArray; } } }
void OnGUI(){ EditorStyles.textField.wordWrap = true; Repaint(); Rect OldRect = position; OldRect.width=320; OldRect.height=450; if (position.width>320||position.height>450) position = OldRect; maximized = false; GUISkin oldskin = GUI.skin; Vector2 WinSize = new Vector2(position.width,position.height); if(Event.current.type==EventType.Repaint) ShaderUtil.AddProSkin(WinSize); if (!Feature) GUI.Toggle(new Rect(10,10,(WinSize.x-20)/2,30),true,"Report Bug",GUI.skin.GetStyle("ButtonLeft")); else if (GUI.Button(new Rect(10,10,(WinSize.x-20)/2,30),"Report Bug",GUI.skin.GetStyle("ButtonLeft"))) Feature = false; if (Feature) GUI.Toggle(new Rect(10+(WinSize.x-20)/2,10,(WinSize.x-20)/2,30),true,"Suggest Feature",GUI.skin.GetStyle("ButtonLeft")); else if (GUI.Button(new Rect(10+(WinSize.x-20)/2,10,(WinSize.x-20)/2,30),"Suggest Feature",GUI.skin.GetStyle("ButtonLeft"))) Feature = true; int YOffset = 40; GUI.Box(new Rect(5,YOffset,WinSize.x-10,WinSize.y-20),"","Button"); if (!Feature){ GUI.Label(new Rect(10,YOffset+0,WinSize.x-20,100),"Oh no, you've found a bug! Sorry about this, but here's how you can help. Just check a few options and hit send to help Shader Sandwich become even more awesome :)."); GUI.Label(new Rect(10,YOffset+70,WinSize.x-20,20),"Name of the bug:"); BName = GUI.TextField(new Rect(10,YOffset+90,WinSize.x-20,20),BName); YOffset+=50; GUI.Label(new Rect(10,YOffset+70,WinSize.x-20,20),"Whats wrong?"); Error = (ErrorTypes)EditorGUI.IntPopup(new Rect(110,YOffset+70,WinSize.x-120,15),(int)Error,new string[]{"The shaders pink!","Something isn't doing what I expect.","Something else."},new int[]{0,1,2},ShaderUtil.EditorPopup); //EditorGUI.TextField(new Rect(0,60,WinSize.x-10,20),"ASD"); GUI.Label(new Rect(10,YOffset+95,WinSize.x-20,20),"Got any details you think are important?"); GUI.SetNextControlName("Context"); //Debug.Log((GUI.GetNameOfFocusedControl()!="Context"&&Context==" ")?("Then type them here!"+UnityEngine.Random.value.ToString()):Context); string Con = EditorGUI.TextArea(new Rect(10, YOffset+120, WinSize.x-20, 90), (!EditingContext)?("Then type them here!"):BContext, GUI.skin.textArea); if (GUI.GetNameOfFocusedControl()!="Context"&&BContext==""){ // EditorGUI.TextArea(new Rect(0, 110, WinSize.x-20, 100), "Then type them here!", GUI.skin.textField); // InArea = 0; } else{ if (!EditingContext){ GUI.FocusControl(""); } EditingContext = true; } if (EditingContext){ if (!Refocused&&Event.current.type==EventType.Repaint){ Refocused = true; GUI.FocusControl("Context"); } if (Refocused) BContext = Con; } YOffset-=10; GUIStyle ButtonStyle = new GUIStyle(GUI.skin.button); ButtonStyle.padding = new RectOffset(0,0,0,0); ButtonStyle.margin = new RectOffset(0,0,0,0); GUI.Label(new Rect(10, YOffset+220, WinSize.x-20, 20),"Your email address:"); YOffset+=20; BEmail = GUI.TextField(new Rect(10, YOffset+220, WinSize.x-20, 20),BEmail); YOffset+=30; GUI.Label(new Rect(10, YOffset+220, WinSize.x-20, 20),"Include current shader (Please do!)"); Rect rect = new Rect(WinSize.x-30, YOffset+220, 20, 20); if (IncludeCurrentShader) IncludeCurrentShader = GUI.Toggle(rect,IncludeCurrentShader,ShaderSandwich.Tick,ButtonStyle); else IncludeCurrentShader = GUI.Toggle(rect,IncludeCurrentShader,ShaderSandwich.Cross,ButtonStyle); YOffset+=25; GUI.Label(new Rect(10, YOffset+220, WinSize.x-20, 20),"Make the bug private"); rect = new Rect(WinSize.x-30, YOffset+220, 20, 20); if (Private) Private = GUI.Toggle(rect,Private,ShaderSandwich.Tick,ButtonStyle); else Private = GUI.Toggle(rect,Private,ShaderSandwich.Cross,ButtonStyle); //Private=false; } if (Feature){ GUI.Label(new Rect(10,YOffset+0,WinSize.x-20,100),"So, you think you've got a cool idea for a feature? Well tell us about it, and we might add it in!"); GUI.Label(new Rect(10,YOffset+70,WinSize.x-20,20),"Name of the feature:"); FName = GUI.TextField(new Rect(10,YOffset+90,WinSize.x-20,20),FName); YOffset+=50; GUI.Label(new Rect(10,YOffset+70,WinSize.x-20,20),"How important is this feature to you?"); YOffset+=20; FeatureImportance = (FeatureTypes)EditorGUI.IntPopup(new Rect(10,YOffset+70,WinSize.x-80,15),(int)FeatureImportance,new string[]{"I can wait ages for it.","It would come in handy soon.","I really need it for the shader I'm making!"},new int[]{0,1,2},ShaderUtil.EditorPopup); //EditorGUI.TextField(new Rect(0,60,WinSize.x-10,20),"ASD"); GUI.Label(new Rect(10,YOffset+95,WinSize.x-20,20),"So whats your cool idea? Please use detail :)."); //Debug.Log((GUI.GetNameOfFocusedControl()!="Context"&&Context==" ")?("Then type them here!"+UnityEngine.Random.value.ToString()):Context); string Con = EditorGUI.TextArea(new Rect(10, YOffset+120, WinSize.x-20, 100), FContext, GUI.skin.textArea); FContext = Con; GUI.Label(new Rect(10, YOffset+220, WinSize.x-20, 20),"Your email address:"); YOffset+=20; BEmail = GUI.TextField(new Rect(10, YOffset+220, WinSize.x-20, 20),BEmail); YOffset+=30; } if (GUI.Button(new Rect(10,WinSize.y-50,100,40),"Submit!")){ int Option = 0; if (!Feature) Option = EditorUtility.DisplayDialog("Ready?","Cool, your bug report is about to be submitted. Along with it will be some system info like \nUnity "+Application.unityVersion+"\n" +SystemInfo.operatingSystem+"\n" +SystemInfo.deviceModel+"\n" +SystemInfo.graphicsDeviceName+"\nSM"+ (SystemInfo.graphicsShaderLevel/10).ToString()+"\n\n"+ "This stuff is important for fixing the bug, so if that's ok just click \"Go Ahead\"!","Go ahead!","Sorry, not yet.")?0:1; if (Feature) Option = EditorUtility.DisplayDialogComplex("Ready?","Cool, your feature idea is about to be submitted. If you want you can also submit some system info like \nUnity "+Application.unityVersion+"\n" +SystemInfo.operatingSystem+"\n" +SystemInfo.deviceModel+"\n" +SystemInfo.graphicsDeviceName+"\nSM"+ (SystemInfo.graphicsShaderLevel/10).ToString()+"\n\n"+ "This is useful to me for statistical purposes and stuff, but if you want you can choose not to submit it.","Submit with data!","Don't submit yet.","Submit without data."); if (Option==0||Option==2){ WWWForm form = new WWWForm(); WWW www; if (!Feature){ form.AddField("SSV", "1.2");//[email protected] form.AddField("Email", BEmail);//[email protected] form.AddField("Unity", Application.unityVersion);//Unity 5.02f form.AddField("OS", SystemInfo.operatingSystem);//Windows 7 form.AddField("CPU", SystemInfo.deviceModel);//Intel(R) form.AddField("CName", "Nup");//SystemInfo.deviceName);//IMACATLOL-HP form.AddField("Name", BName); form.AddField("GPU", SystemInfo.graphicsDeviceName);//NVIDIA form.AddField("CID", SystemInfo.deviceUniqueIdentifier);//1fe8504986mgf003sfbtrt form.AddField("ShaderModel", (SystemInfo.graphicsShaderLevel/10).ToString());//3 if (IncludeCurrentShader&&ShaderSandwich.Instance!=null&&ShaderSandwich.Instance.OpenShader!=null){ string GenStr = ""; try { GenStr = ShaderSandwich.Instance.OpenShader.GenerateCode(true); } catch{} form.AddField("File",GenStr+"\n\n/*\n"+ShaderSandwich.Instance.OpenShader.Save()+"\n*/"); } else if (ShaderSandwich.Instance==null||ShaderSandwich.Instance.OpenShader==null){ form.AddField("File", "Couldn't"); } else if (ShaderSandwich.Instance!=null&&ShaderSandwich.Instance.OpenShader!=null){ form.AddField("File", "Nup"); } form.AddField("Private", Private ? "1":"0"); form.AddField("Attr", Error.ToString()); form.AddField("Context", BContext); form.AddField("Type", "Bug"); } else{ if (Option==0){ form.AddField("SSV", "1.2"); form.AddField("Email", BEmail);//[email protected] form.AddField("Unity", Application.unityVersion);//Unity 5.02f form.AddField("OS", SystemInfo.operatingSystem);//Windows 7 form.AddField("CPU", SystemInfo.deviceModel);//Intel(R) form.AddField("CName", "Nup");//SystemInfo.deviceName);//IMACATLOL-HP form.AddField("Name", FName); form.AddField("GPU", SystemInfo.graphicsDeviceName);//NVIDIA form.AddField("CID", SystemInfo.deviceUniqueIdentifier);//1fe8504986mgf003sfbtrt form.AddField("ShaderModel", (SystemInfo.graphicsShaderLevel/10).ToString());//3 //form.AddField("Private", Private ? "1":"0"); form.AddField("Attr", FeatureImportance.ToString()); form.AddField("Context", FContext); form.AddField("Type", "Feature"); } if (Option==2){ form.AddField("SSV", "1.2"); form.AddField("Email", BEmail);//[email protected] form.AddField("Unity", "Nup");//Unity 5.02f form.AddField("OS", "Nup");//Unity 5.02f form.AddField("CPU", "Nup");//Intel(R) form.AddField("CName", "Nup");//SystemInfo.deviceName);//IMACATLOL-HP form.AddField("Name", FName); form.AddField("GPU", "Nup");//NVIDIA form.AddField("CID", "Nup");//1fe8504986mgf003sfbtrt form.AddField("ShaderModel", "Nup");//3 //form.AddField("Private", Private ? "1":"0"); form.AddField("Attr", FeatureImportance.ToString()); form.AddField("Context", FContext); form.AddField("Type", "Feature"); } } www = new WWW("http://electronic-mind.org/scripts/SSFeedbackReport.php", form); double Start = EditorApplication.timeSinceStartup; while (!(www.isDone==true||(EditorApplication.timeSinceStartup-Start>15))) { EditorUtility.DisplayProgressBar("Submitting!","Your "+(Feature?"feature":"bug")+" is now being uploaded!",((float)(EditorApplication.timeSinceStartup-Start))/15f); } EditorUtility.ClearProgressBar(); if (www.isDone==true){ EditorUtility.DisplayDialog("Success!","Ok, I'll take a look at it shortly, you can watch the progress of it on electronic-mind.org in the Shader Sandwich bug/feature area.","Cool!"); Help.BrowseURL("http://electronic-mind.org/Pages/ShaderSandwichFeedbackView.php?id="+www.text); } else EditorUtility.DisplayDialog("Oops!","Sorry, something went wrong :(. You can try submitting again, or try a bit later. If it's urgent just email me at [email protected] :).","Ok."); //Debug.Log( www.text); } } GUI.skin = oldskin; }
private static Brush GetTerrainBrush(TerrainTypes terrainType, PlotTypes plotType, FeatureTypes featureType, bool isEmpty) { if (isEmpty) return new SolidColorBrush(Colors.Transparent); string key = GetTerrainImageKey(terrainType, plotType, featureType); Image img = App.Current.Resources[key] as Image; if (img != null) return new ImageBrush(img.Source); return new SolidColorBrush(Color.FromRgb(0, 0, 0)); }
/// <summary> /// Creates a new class of vector that matches the given filename. /// </summary> /// <param name="filename">The string filename from which to create a vector.</param> /// <param name="featureType">Specifies the type of feature for this vector file</param> /// <param name="progHandler">Overrides the default progress handler with the specified progress handler</param> /// <returns>An IFeatureSet that allows working with the dataset.</returns> public IFeatureSet CreateVector(string filename, FeatureTypes featureType, IProgressHandler progHandler) { // To Do: Add Customization that allows users to specify which plugins to use in priority order. IFeatureSet result; // First check for the extension in the preferred plugins list string ext = Path.GetExtension(filename); if (_preferredProviders.ContainsKey(ext)) { VectorProvider vp = _preferredProviders[ext] as VectorProvider; if (vp != null) { result = vp.CreateNew(filename, featureType, true, progHandler); if (result != null) return result; } // if we get here, we found the provider, but it did not succeed in opening the file. } // Then check the general list of developer specified providers... but not the directory providers foreach (IDataProvider dp in _dataProviders) { if (GetSupportedExtensions(dp.DialogReadFilter).Contains(ext)) { VectorProvider vp = dp as VectorProvider; if (vp != null) { // attempt to open with the filename. result = vp.CreateNew(filename, featureType, true, progHandler); if (result != null) return result; } } } MessageBox.Show(MessageStrings.FileTypeNotSupported); return null; }
public InstantStatModFeature(float amount, StatTypes stat, FeatureTypes type) : base(amount, stat, type) { }
/// <summary> /// Creates a new shapefile that has a specific feature type /// </summary> /// <param name="featureType"></param> protected Shapefile(FeatureTypes featureType) : base(featureType) { }
/// <summary> /// Attempts to read in an entry to the specified feature type. If the feature type does not match /// the geometry type, this will return null. (A Point geometry will be accepted by MultiPoint /// feature type, but not the other way arround. Either way, this will advance the reader /// through the shape feature. Using the Unspecified will always return the shape it reads, /// or null in the case of mixed feature collections which are not supported. /// </summary> /// <param name="data"></param> /// <param name="featureType"></param> /// <returns></returns> public static Shape ReadShape(Stream data, FeatureTypes featureType) { _endian = (ByteOrder)data.ReadByte(); WkbGeometryTypes type = (WkbGeometryTypes)ReadInt32(data); Shape result; switch (type) { case WkbGeometryTypes.Point: result = ReadPoint(data); if (featureType == FeatureTypes.Point || featureType == FeatureTypes.MultiPoint || featureType == FeatureTypes.Unspecified) { return result; } return null; case WkbGeometryTypes.LineString: result = ReadLineString(data); if (featureType == FeatureTypes.Line || featureType == FeatureTypes.Unspecified) { return result; } return null; case WkbGeometryTypes.Polygon: result = ReadPolygon(data); if (featureType == FeatureTypes.Polygon || featureType == FeatureTypes.Unspecified) { return result; } return null; case WkbGeometryTypes.MultiPoint: result = ReadMultiPoint(data); if(featureType == FeatureTypes.MultiPoint || featureType == FeatureTypes.Unspecified ) { return result; } return null; case WkbGeometryTypes.MultiLineString: result = ReadMultiLineString(data); if (featureType == FeatureTypes.Line || featureType == FeatureTypes.Unspecified) { return result; } return null; case WkbGeometryTypes.MultiPolygon: result = ReadMultiPolygon(data); if (featureType == FeatureTypes.Polygon || featureType == FeatureTypes.Unspecified) { return result; } return null; case WkbGeometryTypes.GeometryCollection: throw new ArgumentException("Mixed shape type collections are not supported by this method."); } return null; }
public FollowerPoint(double x, double y, FeatureTypes edgeType, int targetNumber) { X = x; Y = y; EdgeType = edgeType; }
/// <summary> /// This adds the coordinates and specifies what sort of feature type should be added. /// </summary> /// <param name="self">This IFeatureList</param> /// <param name="points">The list or array of coordinates to be added after it is built into the appropriate feature.</param> /// <param name="featureType">The feature type.</param> public static void Add(this IFeatureList self, IEnumerable<Coordinate> points, FeatureTypes featureType) { if (self.Parent.FeatureType == FeatureTypes.Unspecified) self.Parent.FeatureType = featureType; self.Add(points); }
protected Feature(float amount, StatTypes stat, FeatureTypes type) { this.Amount = amount; this.Stat = stat; this.Type = type; }
public SerializableFeature(Feature feature) { _type = feature.Type; _position = feature.Position; }
public void AddFeature(IntVector2 position, FeatureTypes type) => _features[position] = type;
internal FeatureActivationAttribute(FeatureTypes requiredFeatureTypes, IFeatureLicenseHelper featureLicenseHelper) { _requiredFeatureTypes = requiredFeatureTypes; _featureLicenseHelper = featureLicenseHelper; }
// TODO: framework for checking if the feature values are mmeting requirements. /// <summary> Adds feature(column) to the feature representation. </summary> /// <param name="isSparse"> /// It doesn't affect the flags, they are always sparse. /// </param> public void AddFeature( float[] values, InputFeatureTypes type, bool isSparse = false) { FeatureTypes.Add(type); var sIndices = new List <int>(); if (InstancesCount != 0) { if (InstancesCount != values.Length) { throw new ArgumentException("The feature length is different than instances count."); } } else { InstancesCount = values.Length; } switch (type) { case InputFeatureTypes.Ordinal: if (IsSortedDataset) { if (isSparse) { SortSparseInput( values, out var nonZeroSortedValues, out var nonZeroSortedIndices, out var negCount); Features.Add(new SparseFeature( values: nonZeroSortedValues, sortedIndices: nonZeroSortedIndices, length: values.Length, scopeOffset: 0, scopeCount: nonZeroSortedIndices.Length, negCount: negCount)); break; } else { var sortedIndices = new int[values.Length]; for (var i = 0; i < values.Length; i++) { sortedIndices[i] = i; } Array.Sort(values, sortedIndices); Features.Add(new DenseFeature(values, sortedIndices, 0, values.Length)); break; } } if (isSparse) { var sValues = new List <float>(); for (var i = 0; i < values.Length; i++) { if (values[i] > 0f) { sValues.Add(values[i]); sIndices.Add(i); } } Features.Add(new SparseFeature( values: sValues.ToArray(), sortedIndices: sIndices.ToArray(),// Not sorted case; length: values.Length, scopeOffset: 0, scopeCount: sIndices.Count, negCount: -1));// Not sorted case; break; } var copiedValues = new float[values.Length]; Array.Copy(values, copiedValues, values.Length); Features.Add(new DenseFeature(values)); break; case InputFeatureTypes.Flags: for (var i = 0; i < values.Length; i++) { if (values[i] > 0f) { sIndices.Add(i); } } Features.Add(new BinaryFeature(sIndices.ToArray(), values.Length, 0, sIndices.Count)); break; } }
/// <summary> /// Creates a new class of vector that matches the given filename. /// </summary> /// <param name="filename">The string filename from which to create a vector.</param> /// <param name="featureType">Specifies the type of feature for this vector file</param> /// <returns>An IFeatureSet that allows working with the dataset.</returns> public IFeatureSet CreateVector(string filename, FeatureTypes featureType) { return CreateVector(filename, featureType, _progressHandler); }
/// <summary> /// StartRange, count and vertices will be declared later. /// </summary> /// <param name="featureType"></param> public PartRange(FeatureTypes featureType) { _featureType = featureType; }
public void SetupLicenseHelperMock(FeatureTypes featureTypes = FeatureTypes.None) { _licenseHelperMock .Setup(l => l.GetValidBlueprintLicenseFeatures()) .Returns(featureTypes); }
/// <summary> /// Creates a blank instance of a shaperange where vertices can be assigned later. /// </summary> public ShapeRange(FeatureTypes type) { FeatureType = type; Parts = new List<PartRange>(); _numParts = -1; // default to relying on the parts list instead of the cached value. _numPoints = -1; // rely on accumulation from parts instead of a solid number }
private static string GetTerrainImageKey(TerrainTypes terrainType, PlotTypes plotType, FeatureTypes featureType) { if (plotType == PlotTypes.PEAK) return "PEAK"; else if (featureType == FeatureTypes.FEATURE_ICE) return "ICE"; else if (featureType == FeatureTypes.FEATURE_OASIS) return "OASIS"; string key = ""; if (featureType == FeatureTypes.FEATURE_JUNGLE) key = "JUNGLE"; else key = terrainType.ToString().Replace("TERRAIN_", ""); if ((terrainType == TerrainTypes.TERRAIN_GRASS || terrainType == TerrainTypes.TERRAIN_PLAINS || terrainType == TerrainTypes.TERRAIN_TUNDRA) && featureType == FeatureTypes.FEATURE_FOREST) key += "_FOREST"; if ((terrainType == TerrainTypes.TERRAIN_GRASS || terrainType == TerrainTypes.TERRAIN_PLAINS || terrainType == TerrainTypes.TERRAIN_TUNDRA || terrainType == TerrainTypes.TERRAIN_SNOW || terrainType == TerrainTypes.TERRAIN_DESERT) && plotType == PlotTypes.HILL) key += "_HILL"; return key; }
/// <summary> /// This creates a polygon shape from an extent. /// </summary> /// <param name="ext">The extent to turn into a polygon shape.</param> public ShapeRange(Extent ext) { Extent = ext; Parts = new List<PartRange>(); _numParts = -1; // Counter clockwise // 1 2 // 4 3 double[] coords = new double[8]; // C1 coords[0] = ext.XMin; coords[1] = ext.YMax; // C2 coords[2] = ext.XMax; coords[3] = ext.YMax; // C3 coords[4] = ext.XMax; coords[5] = ext.YMin; // C4 coords[6] = ext.XMin; coords[7] = ext.YMin; FeatureType = FeatureTypes.Polygon; ShapeType = ShapeTypes.Polygon; PartRange pr = new PartRange(coords, 0,0, FeatureTypes.Polygon); pr.NumVertices = 4; Parts.Add(pr); }
public static Type ConvertToType(FeatureTypes enumType) => _enumToType[enumType];
public FeatureCenterPair(MapCoor center, FeatureTypes featureType) { this.center = center; this.featureType = featureType; }
public ContinuesStatModFeature(float duration, float interval, float amount, StatTypes stat, FeatureTypes type) : base(amount, stat, type) { Duration = duration; Interval = interval; }
/// <summary> /// This create new method implies that this provider has the priority for creating a new file. /// An instance of the dataset should be created and then returned. By this time, the filename /// will already be checked to see if it exists, and deleted if the user wants to overwrite it. /// </summary> /// <param name="filename">The string filename for the new instance</param> /// <param name="featureType">Point, Line, Polygon etc. Sometimes this will be specified, sometimes it will be "Unspecified"</param> /// <param name="inRam">Boolean, true if the dataset should attempt to store data entirely in ram</param> /// <param name="progressHandler">An IProgressHandler for status messages.</param> /// <returns>An IRaster</returns> public virtual IFeatureSet CreateNew(string filename, FeatureTypes featureType, bool inRam, IProgressHandler progressHandler) { if (featureType == FeatureTypes.Point) { PointShapefile ps = new PointShapefile(); ps.Filename = filename; return ps; } else if (featureType == FeatureTypes.Line) { LineShapefile ls = new LineShapefile(); ls.Filename = filename; return ls; } else if (featureType == FeatureTypes.Polygon) { PolygonShapefile ps = new PolygonShapefile(); ps.Filename = filename; return ps; } else if (featureType == FeatureTypes.MultiPoint) { MultiPointShapefile mps = new MultiPointShapefile(); mps.Filename = filename; return mps; } return null; }
/// <summary> /// Creates a new instance of Part /// </summary> /// <param name="allVertices">An array of all the vertex locations</param> /// <param name="shapeOffset">The point index of the shape. </param> /// <param name="partOffset">The ponit index of the part.</param> /// <param name="featureType">The type of features.</param> public PartRange(double[] allVertices, int shapeOffset, int partOffset , FeatureTypes featureType): base(allVertices, shapeOffset, partOffset) { _segments = new SegmentRange(this, featureType); _featureType = featureType; }
public TempStatModFeature(float duration, float amount, StatTypes stat, FeatureTypes type) : base(amount, stat, type) { Duration = duration; }
/// <summary> /// Creates a new "point" shape that has only the one point. /// </summary> /// <param name="v"></param> public ShapeRange(Vertex v) { FeatureType = FeatureTypes.Point; Parts = new List<PartRange>(); _numParts = -1; double[] coords = new double[2]; coords[0] = v.X; coords[1] = v.Y; PartRange prt = new PartRange(coords, 0,0, FeatureTypes.Point); prt.NumVertices = 1; Parts.Add(prt); }
/// <summary> /// Creates a new shape type where the shaperange exists and has a type specified /// </summary> /// <param name="type"></param> public Shape(FeatureTypes type) { _shapeRange = new ShapeRange(type); }
/// <summary> /// Creates a new FeatureSet /// </summary> /// <param name="featureType">The Feature type like point, line or polygon</param> public FeatureSet(FeatureTypes featureType) : this() { _featureType = featureType; }
public void Fatal(string message, FeatureTypes featureType = FeatureTypes.Default, object[] args = null, [CallerMemberName] string caller = "") { UnityEngine.Debug.LogError($"{featureType.ToString().ToUpper()} ({caller}) :: {message}; args: {JoinArgs(args)}"); // TODO: Add stacktrace }
public void Warn(string message, FeatureTypes featureType = FeatureTypes.Default, object[] args = null, string caller = "") { UnityEngine.Debug.LogWarning($"{featureType.ToString().ToUpper()} ({caller}) :: {message}; args: {JoinArgs(args)}"); }
public FeatureActivationAttribute(FeatureTypes requiredFeatureTypes) : this(requiredFeatureTypes, FeatureLicenseHelper.Instance) { }
public FeatureCenterPair(MapCoor center, FeatureTypes featureType, bool mirrored = false) { this.center = center; this.featureType = featureType; this.mirrored = mirrored; }
public BlockBuilder SetFeature(FeatureTypes feature) { _feature = feature; return(this); }