private void miChangeLink_Click(object sender, EventArgs e)
{
ListViewItem item = lvEntity.FocusedItem;
if (item != null && item.Tag != null)
{
GroupItem gitem = (GroupItem)item.Tag;
string PtName = (gitem.Name.Length > 0) ? gitem.Name : lastPtName;
string PtParam = (gitem.Param.Length > 1) ? gitem.Param : lastPtParam;
PointSelector kind = (ParamGroupKind == ParamGroup.Trend) ?
PointSelector.TrendPoints : PointSelector.TablePoints;
using (frmEntitySelector form =
new frmEntitySelector(PtName, PtParam, kind))
{
if (form.ShowDialog() == DialogResult.OK)
{
int index = item.Index;
lastPtName = form.EntityName;
lastPtParam = form.EntityParam;
updateGroupItem(gitem, lastPtName, lastPtParam);
UpdateGroupItemsList(index);
}
}
}
}
/// <summary>
/// Radial basis function interpolated surface
/// </summary>
/// <param name="selector">Points to build surface on</param>
/// <param name="rcsProvider">Radio cross section provider</param>
/// <param name="baseRadius">Average distance between points</param>
/// <param name="layers">Layers number</param>
/// <param name="lambda">Regularization coef</param>
public RbfMultilayer(PointSelector.CompressedPointSelectorWrapper selector, IInterpolationProvider rcsProvider,
int baseRadius, int layers, double lambda = 0.01)
: base(selector, rcsProvider)
{
_baseRadius = baseRadius;
_layers = layers;
_lambda = lambda;
}
public ItemDrawer(PointSelector.PointSelector pointSelector,
AreaSelector.AreaSelector areaSelector, RlViewer.Behaviors.Scaling.Scaler scaler,
AreaSelector.AreaSelectorsAlignerContainer areaAlignerWrapper) : base(scaler)
{
_pointSelector = pointSelector;
_areaSelector = areaSelector;
_areaAlignerWrapper = areaAlignerWrapper;
}
public Aligning(Files.LocatorFile file, PointSelector.CompressedPointSelectorWrapper selector,
Behaviors.ImageAligning.IInterpolationProvider rcsProvider,
Behaviors.ImageAligning.Surfaces.SurfaceType surfaceType, int baseRadius, int layers, double lambda)
{
_file = file;
_selector = selector;
_surface = Factories.Surface.SurfaceFactory.CreateSurface(_selector, rcsProvider, surfaceType, baseRadius, layers, lambda);
}
public void TestModeChangeWhileDisconnected()
{
PointSelector selector = new PointSelector();
selector.Mode = PointSelectorMode.Add;
selector.Mode = PointSelectorMode.MultipleSelect;
selector.Mode = PointSelectorMode.Remove;
}
// Random parameters governing the overall shape of the island -- not using variant
public void newIsland(string islandType, int numPoints_, float seed, float variant){
if (islandType == "Perlin") { islandShape = new MakePerlin(seed); }
else if (islandType == "Radial") { islandShape = new MakeRadial(seed); }
else if (islandType == "Square") { islandShape = new MakeSquare(); }
else if (islandType == "Hex") { }
pointSelector = new PointSelector ((int)SIZE, seed);
numPoints = numPoints_;
//mapRandom = new System.Random (variant);
mapRandom = seed;
}
public frmEntitySelector(string name, string param, PointSelector kind)
{
InitializeComponent();
IDictionary <string, IPointPlugin> plugins = PointPlugin.LoadPlugins(Application.StartupPath);
foreach (KeyValuePair <string, IPointPlugin> plugin in plugins)
{
using (Bitmap bmp = new Bitmap(16, 16))
{
Graphics g = Graphics.FromImage(bmp);
Data.DrawIconImage(Graphics.FromImage(bmp),
plugin.Value.GetIconColor, plugin.Value.PluginShortType);
ilList.Images.Add(bmp);
}
IconList.Add(plugin.Value.PluginCategory + plugin.Value.PluginShortType,
ilList.Images.Count - 1);
}
switch (kind)
{
case PointSelector.AllPoints: FillItemsForAllPoints(ilList, IconList); break;
case PointSelector.TrendPoints: FillItemsForTrendPoints(ilList, IconList); break;
case PointSelector.TablePoints: FillItemsForTablePoints(ilList, IconList); break;
case PointSelector.AnalogPoints: FillItemsForAnalogPoints(ilList, IconList); break;
case PointSelector.DigitalPoints: FillItemsForDigitalPoints(ilList, IconList); break;
case PointSelector.KonturPoints: FillItemsForKonturPoints(ilList, IconList); break;
case PointSelector.ValvePoints: FillItemsForValvePoints(ilList, IconList); break;
}
this.EntityName = name;
this.EntityParam = param;
ListViewItem item = lvItems.FindItemWithText(name +
((param.Length > 0) ? "." + param : String.Empty));
if (item != null)
{
item.EnsureVisible();
lvItems.FocusedItem = item;
item.Selected = true;
btnOk.Enabled = true;
}
}
public void NewIsLand(IsLandShapeType islandType, PointType pointType, int numPoints, uint seed, uint variant)
{
switch (islandType)
{
case IsLandShapeType.Perlin:
IslandShapeGen = IsLandShape.MakePerlin(seed);
break;
case IsLandShapeType.Radial:
IslandShapeGen = IsLandShape.MakeRadial(seed);
break;
case IsLandShapeType.Square:
IslandShapeGen = IsLandShape.MakeSquare(seed);
break;
default:
break;
}
switch (pointType)
{
case PointType.Random:
PointSelectorGen = PointSelector.generateRandom(MapSize, seed);
break;
case PointType.Relaxed:
PointSelectorGen = PointSelector.generateRelaxed(MapSize, seed);
break;
case PointType.Square:
PointSelectorGen = PointSelector.generateSquare(MapSize, seed);
break;
case PointType.Hexagon:
PointSelectorGen = PointSelector.generateHexagon(MapSize, seed);
break;
default:
break;
}
NeedsMoreRandomness = PointSelector.needsMoreRandomness(pointType);
NumPoints = numPoints;
ParkMillerRng.Seed = variant;
}
public Surface16Points(PointSelector.CompressedPointSelectorWrapper selector, IInterpolationProvider rcsProvider)
: base(selector)
{
_rcsProvider = rcsProvider;
for (int i = 0; i < 4; i++)
{
_zCoefficients[i] = LinearEquation.SolveEquation(
Selector.Skip(i * 4).Take(4).Select(x => (float)x.Location.X).ToArray(),
Selector.Skip(i * 4).Take(4).Select(x => x.Value).ToArray());
_yCoefficients[i] = LinearEquation.SolveEquation(
Selector.Skip(i * 4).Take(4).Select(x => (float)x.Location.X).ToArray(),
Selector.Skip(i * 4).Take(4).Select(x => (float)x.Location.Y).ToArray());
}
}
// Random parameters governing the overall shape of the island -- not using variant
public void newIsland(string islandType, int numPoints_, float seed, float variant)
{
if (islandType == "Perlin")
{
islandShape = new MakePerlin(seed);
}
else if (islandType == "Radial")
{
islandShape = new MakeRadial(seed);
}
else if (islandType == "Square")
{
islandShape = new MakeSquare();
}
else if (islandType == "Hex")
{
}
pointSelector = new PointSelector((int)SIZE, seed);
numPoints = numPoints_;
//mapRandom = new System.Random (variant);
mapRandom = seed;
}
public RbfSurface(PointSelector.CompressedPointSelectorWrapper selector, IInterpolationProvider rcsProvider)
: base(selector)
{
_rcsProvider = rcsProvider;
}
public RbfMultilayerCoef(PointSelector.CompressedPointSelectorWrapper selector, IInterpolationProvider rcsProvider,
int baseRadius, int layers, double lambda = 0.01) : base(selector, rcsProvider, baseRadius, layers, lambda)
{
}
public NormalizingPlane(PointSelector.CompressedPointSelectorWrapper selector)
: base(selector)
{ }
public Map Generate(Vector2 dimensions,
int seed,
PointSelector.FaceType faceType,
IslandShape.FunctionType functionType,
float height,
AnimationCurve heightMap,
int regionCount,
int relaxationCount,
float radius)
{
data = new Map();
data.seed = seed;
this.height = height;
this.heigtMap = heightMap;
islandShape = new IslandShape(seed, dimensions.x, dimensions.y, functionType);
rectangle = new Rectangle(0, 0, dimensions.x, dimensions.y);
if (faceType == PointSelector.FaceType.Hexagon || faceType == PointSelector.FaceType.Square)
{
relaxationCount = 0;
}
Polygon polygon = PointSelector.Generate(dimensions, seed, faceType, regionCount, radius);
VoronoiBase voronoi = GenerateVoronoi(ref polygon, relaxationCount);
Build(polygon, voronoi);
ImproveCorners();
// Determine the elevations and water at Voronoi corners.
Elevation.AssignCorner(ref data, islandShape, faceType == PointSelector.FaceType.Hexagon || faceType == PointSelector.FaceType.Square);
// Determine polygon and corner type: ocean, coast, land.
Biomes.AssignOceanCoastAndLand(ref data);
// Rescale elevations so that the highest is 1.0, and they're
// distributed well. We want lower elevations to be more common
// than higher elevations, in proportions approximately matching
// concentric rings. That is, the lowest elevation is the
// largest ring around the island, and therefore should more
// land area than the highest elevation, which is the very
// center of a perfectly circular island.
List <Graph.Corner> corners = LandCorners(data.corners);
Elevation.Redistribute(ref corners);
// Assign elevations to non-land corners
foreach (var q in data.corners)
{
if (q.ocean || q.coast)
{
q.elevation = 0.0f;
}
}
// Polygon elevations are the average of their corners
Elevation.AssignPolygon(ref data);
// Determine moisture at corners, starting at rivers
// and lakes, but not oceans. Then redistribute
// moisture to cover the entire range evenly from 0.0
// to 1.0. Then assign polygon moisture as the average
// of the corner moisture.
Moisture.AssignCorner(ref data);
Moisture.Redistribute(ref corners);
Moisture.AssignPolygon(ref data);
Biomes.AssignBiomes(ref data);
return(data);
}
public RbfQnnCoef(PointSelector.CompressedPointSelectorWrapper selector, IInterpolationProvider rcsProvider)
: base(selector, rcsProvider)
{
}
void Start()
{
pointSelector = GameObject.Find("Point Selector").GetComponent <PointSelector>();
}
public Surface(PointSelector.CompressedPointSelectorWrapper selector)
{
Selector = selector;
Selector.SetSelector(new Behaviors.PointSelector.PointSelector(OrderAsMatrix(selector.CompessedSelector.ToList())));
}
protected override void AttachCore(PointSelector selector, Plotter plotter)
{
// do nothing here
}
public override void ToDo(object Arg)
{
b = new BoxController();
b.Init("USB0::0x0957::0x1718::TW54334510::INSTR");
var _ch = new AI_ChannelConfig[4]
{
new AI_ChannelConfig()
{
ChannelName = AnalogInChannelsEnum.AIn1, Enabled = true, Mode = ChannelModeEnum.DC, Polarity = PolarityEnum.Polarity_Bipolar, Range = RangesEnum.Range_1_25
},
new AI_ChannelConfig()
{
ChannelName = AnalogInChannelsEnum.AIn2, Enabled = false, Mode = ChannelModeEnum.DC, Polarity = PolarityEnum.Polarity_Bipolar, Range = RangesEnum.Range_1_25
},
new AI_ChannelConfig()
{
ChannelName = AnalogInChannelsEnum.AIn3, Enabled = false, Mode = ChannelModeEnum.DC, Polarity = PolarityEnum.Polarity_Bipolar, Range = RangesEnum.Range_1_25
},
new AI_ChannelConfig()
{
ChannelName = AnalogInChannelsEnum.AIn4, Enabled = false, Mode = ChannelModeEnum.DC, Polarity = PolarityEnum.Polarity_Bipolar, Range = RangesEnum.Range_1_25
}
};
b.ConfigureAI_Channels(_ch);
var freq = 500000;
var updNumber = 1;
var avgNumber = 1000;
double[] autoPSDLowFreq;
double[] autoPSDHighFreq;
Point[] noisePSD = new Point[] { };
if (freq % 2 != 0)
{
throw new ArgumentException("The frequency should be an even number!");
}
b.AcquisitionInProgress = true;
b.AI_ChannelCollection[AnalogInChannelsEnum.AIn1].DataReady += DefResistanceNoise_DataReady;
var sb = new StringBuilder();
double dtLowFreq = 0.0, dtHighFreq = 0.0;
double dfLowFreq = 1.0, dfHighFreq = 0.0;
double equivalentNoiseBandwidthLowFreq, equivalentNoiseBandwidthHighFreq;
double coherentGainLowFreq, coherentGainHighFreq;
Parallel.Invoke(
() =>
{
b.StartAnalogAcquisition(freq);
IsRunning = false;
},
() =>
{
while (true)
{
if (!IsRunning)
{
b.AcquisitionInProgress = false;
break;
}
if (averagingCounter >= avgNumber)
{
b.AcquisitionInProgress = false;
break;
}
Point[] timeTrace;
var dataReadingSuccess = b.AI_ChannelCollection[AnalogInChannelsEnum.AIn1].ChannelData.TryDequeue(out timeTrace);
if (dataReadingSuccess)
{
var query = from val in timeTrace
select val.Y;
var counter = 0;
var traceData = new double[timeTrace.Length];
foreach (var item in query)
{
traceData[counter] = item;
++counter;
}
var unit = new System.Text.StringBuilder("V", 256);
var sw = ScaledWindow.CreateRectangularWindow();
// Calculation of the low-frequency part of the spectrum
sw.Apply(traceData, out equivalentNoiseBandwidthLowFreq, out coherentGainLowFreq);
dtLowFreq = 1.0 / (double)freq;
autoPSDLowFreq = Measurements.AutoPowerSpectrum(traceData, dtLowFreq, out dfLowFreq);
var singlePSDLowFreq = Measurements.SpectrumUnitConversion(autoPSDLowFreq, SpectrumType.Power, ScalingMode.Linear, DisplayUnits.VoltsPeakSquaredPerHZ, dfLowFreq, equivalentNoiseBandwidthLowFreq, coherentGainLowFreq, unit);
// Calculation of the hugh-frequency part of the spectrum
var selection64Hz = PointSelector.SelectPoints(ref traceData, 64);
sw.Apply(selection64Hz, out equivalentNoiseBandwidthHighFreq, out coherentGainHighFreq);
dtHighFreq = 64.0 * 1.0 / (double)freq;
autoPSDHighFreq = Measurements.AutoPowerSpectrum(selection64Hz, dtHighFreq, out dfHighFreq);
var singlePSDHighFreq = Measurements.SpectrumUnitConversion(autoPSDHighFreq, SpectrumType.Power, ScalingMode.Linear, DisplayUnits.VoltsPeakSquaredPerHZ, dfHighFreq, equivalentNoiseBandwidthHighFreq, coherentGainHighFreq, unit);
var lowFreqSpectrum = singlePSDLowFreq.Select((value, index) => new Point((index + 1) * dfLowFreq, value)).Where(value => value.X <= 1064);
var highFreqSpectrum = singlePSDLowFreq.Select((value, index) => new Point((index + 1) * dfHighFreq, value)).Where(value => value.X > 1064);
noisePSD = new Point[lowFreqSpectrum.Count() + highFreqSpectrum.Count()];
counter = 0;
foreach (var item in lowFreqSpectrum)
{
noisePSD[counter].X = item.X;
noisePSD[counter].Y += item.Y;
++counter;
}
foreach (var item in highFreqSpectrum)
{
noisePSD[counter].X = item.X;
noisePSD[counter].Y += item.Y;
++counter;
}
//for (int i = 0; i < singlePSDLowFreq.Length; i++)
// noisePSD[i] += singlePSDLowFreq[i];
if (averagingCounter % updNumber == 0)
{
sb = new StringBuilder();
for (int i = 0; i < noisePSD.Length; i++)
{
sb.AppendFormat("{0}\t{1}\r\n", (noisePSD[i].X).ToString(NumberFormatInfo.InvariantInfo), (noisePSD[i].Y / (double)averagingCounter).ToString(NumberFormatInfo.InvariantInfo));
}
onDataArrived(new ExpDataArrivedEventArgs(sb.ToString()));
}
}
}
//sb = new StringBuilder();
//for (int i = 0; i < noisePSD.Length; i++)
// sb.AppendFormat("{0}\t{1}\r\n", (noisePSD[i].X).ToString(NumberFormatInfo.InvariantInfo), (noisePSD[i].Y / (double)averagingCounter).ToString(NumberFormatInfo.InvariantInfo));
//onDataArrived(new ExpDataArrivedEventArgs(sb.ToString()));
});
b.Close();
}
