public void TestColorMapping()
{
Log log = new Log("Test ColorMapper");
log.EnableTrace = true;
int nCount = 300;
ColorMapper clrMap = new ColorMapper(0, 1, Color.Black, Color.Red);
double dfVal = 0;
double dfInc = 1.0 / (double)nCount;
for (int i = 0; i < nCount; i++)
{
Color clr = clrMap.GetColor(dfVal);
double dfVal1 = clrMap.GetValue(clr);
log.EXPECT_EQUAL <float>(dfVal1, dfVal, "The value at i = " + i.ToString() + " value = " + dfVal.ToString() + " does not equal value1 = " + dfVal1.ToString());
dfVal += dfInc;
}
dfVal = clrMap.GetValue(Color.FromArgb(0, 130, 124));
log.CHECK_NE(0, dfVal, "The value should not be zero.");
dfVal = clrMap.GetValue(Color.FromArgb(255, 252, 0));
log.CHECK_NE(0, dfVal, "The value should not be zero.");
log.WriteLine("DONE.");
}
public ScatterMultiColor(Coord3d[] coordinates, ColorMapper mapper, float width = 1.0f)
{
_bbox = new BoundingBox3d();
Data = coordinates;
Width = width;
ColorMapper = mapper;
}
public RingExtrapolator(float ringMax, ColorMapper cmap, Color factor)
{
_ringMax = ringMax;
_cmap = cmap;
_factor = factor;
_interpolator = new RingTessellator(0, _ringMax, _cmap, _factor);
}
public void Should_Convert_To_Entity()
{
var colorCommandDto = Domain.Dtos.Color.ColorCommandDto.New("teste", StatusEnum.Enable.Value, Guid.NewGuid());
var entity = ColorMapper.Map(colorCommandDto);
Assert.NotNull(entity);
}
private void HandleChangeAppearance(LuisMRResult result)
{
// Get the colors mentioned in the prediction
var colorEntity = result.PredictionResult.Entities.FirstOrDefaultItem("MR.Color");
if (colorEntity == null)
{
return;
}
// Try to convert the entity color to a Unity color
Color color;
if (!ColorMapper.TryParseCssString(colorEntity.Value.ToLower(), out color))
{
Debug.LogWarning($"The value \"{colorEntity.Value}\" does not map to a known color.");
return;
}
// Get renderer
var renderer = GetComponent <Renderer>();
if (renderer == null)
{
return;
}
// Set the color
renderer.material.color = color;
}
public void Should_Convert_To_Dto()
{
var color = Domain.Entities.Color.New("test", StatusEnum.Enable, TenantId.New());
var dto = ColorMapper.Map(color);
Assert.NotNull(dto);
}
public RingTessellator(float ringMin, float ringMax, ColorMapper cmap, Color factor)
{
_ringMin = ringMin;
_ringMax = ringMax;
_cmap = cmap;
_factor = factor;
}
public async Task <ColorQueryDto> Handle(GetColorQueryRequest request, CancellationToken cancellationToken)
{
var color = await _colorRepository.GetAsync(request.ColorId);
var colorDto = ColorMapper.Map(color);
return(colorDto);
}
public async Task <Unit> Handle(InsertColorCommandRequest request, CancellationToken cancellationToken)
{
var color = ColorMapper.Map(request.ColorInsertDto);
await _colorRepository.InsertAsync(color);
return(Unit.Value);
}
public void Should_Convert_To_List_Of_Dto2()
{
var colors = new Domain.Entities.Color[] { };
var dtos = ColorMapper.Map(colors).ToList();
Assert.Empty(dtos);
Assert.NotNull(dtos);
}
/// <summary>
/// Converts the result collection into an image.
/// </summary>
/// <param name="clrMap">Optionally, specifies a colormap to use.</param>
/// <returns>The image respresentation of the result collection is returned.</returns>
public Image ToImage(ColorMapper clrMap)
{
int nW = (int)Math.Ceiling(Math.Sqrt(m_rgResultsOriginal.Count));
int nH = nW;
Size sz = new Size(nW, nH);
return(ImageData.GetImage(m_rgResultsOriginal, sz, clrMap));
}
public ColorbarImageGenerator(IColorMap map, float min, float max, ITickProvider provider, ITickRenderer renderer)
{
_mapper = new ColorMapper(map, min, max);
_min = min;
_max = max;
_provider = provider;
_renderer = renderer;
}
/**
* This console app will sync products created in the last X time
*/
public static void Main()
{
_cachedEaAuthToken = GetEaAuthToken();
_cachedMagentoAuthToken = GetMagentoAuthToken();
var controllerFactory = new ControllerFactory(_cachedMagentoAuthToken, _cachedEaAuthToken);
var assetsController = controllerFactory.CreateController(ControllerType.Assets) as AssetsController;
var availabilityController = controllerFactory.CreateController(ControllerType.Availability) as AvailabilityController;
var catalogsController = controllerFactory.CreateController(ControllerType.Catalogs) as CatalogsController;
var entitiesController = controllerFactory.CreateController(ControllerType.Entities) as EntitiesController;
var fieldController = controllerFactory.CreateController(ControllerType.FieldDefinition) as FieldDefinitionController;
var ordersController = controllerFactory.CreateController(ControllerType.Orders) as OrdersController;
var pricingController = controllerFactory.CreateController(ControllerType.Pricing) as PricingController;
var productLibraryController = controllerFactory.CreateController(ControllerType.ProductLibrary) as ProductLibraryController;
var cartController = controllerFactory.CreateController(ControllerType.Cart) as CartController;
var attributesController = controllerFactory.CreateController(ControllerType.CustomAttributes) as CustomAttributesController;
var customerController = controllerFactory.CreateController(ControllerType.Customer) as CustomerController;
var productController = controllerFactory.CreateController(ControllerType.Product) as ProductController;
var regionController = controllerFactory.CreateController(ControllerType.Region) as RegionController;
_productMapper = new ProductMapper(catalogsController, productLibraryController, productController);
_assetMapper = new AssetMapper(assetsController, productLibraryController, catalogsController);
_availabilityMapper = new AvailabilityMapper(availabilityController);
_colorMapper = new ColorMapper(attributesController, productLibraryController);
_fieldMapper = new FieldMapper(productLibraryController, productController, fieldController, catalogsController, attributesController);
_pricingMapper = new PricingMapper(pricingController);
_orderMapper = new OrderMapper(ordersController, catalogsController, cartController, productController);
_entityMapper = new EntityMapper(entitiesController, regionController);
_customerMapper = new CustomerMapper(customerController);
bool doOrderSync;
bool productsSynced = ProductSync();
if (productsSynced)
{
Console.WriteLine("Products successfully synced");
doOrderSync = true;
}
else
{
Console.WriteLine("An error occurred while syncing products to Endless Aisle. Check errorLog.txt for more details.");
Console.WriteLine("Continue on to synchronizing Orders to Magento?");
doOrderSync = Console.ReadKey().ToString().Equals(UserAffirmativeString, StringComparison.OrdinalIgnoreCase);
}
//Order syncing
if (doOrderSync)
{
bool ordersSynced = OrderSync();
Console.WriteLine(ordersSynced
? "Orders successfully synced"
: "An error occurred while syncing orders to Magento. Check errorLog.txt for more details.");
}
Console.WriteLine("Press enter to exit...");
Console.ReadLine();
}
/// <summary>
/// The OnOverlay callback is called just before displaying the gym image, thus allowing for an overlay to be applied to the image.
/// </summary>
/// <param name="e">Specifies the arguments to the callback which contains the original display image.</param>
public void OnOverlay(OverlayArgs e)
{
Blob <T> logits = m_netOutput.blob_by_name("logits");
if (logits == null)
{
return;
}
if (logits.num == 1)
{
m_rgOverlay = Utility.ConvertVecF <T>(logits.mutable_cpu_data);
}
if (m_rgOverlay == null)
{
return;
}
using (Graphics g = Graphics.FromImage(e.DisplayImage))
{
int nBorder = 30;
int nWid = e.DisplayImage.Width - (nBorder * 2);
int nWid1 = nWid / m_rgOverlay.Length;
int nHt1 = (int)(e.DisplayImage.Height * 0.3);
int nX = nBorder;
int nY = e.DisplayImage.Height - nHt1;
ColorMapper clrMap = new ColorMapper(0, m_rgOverlay.Length + 1, Color.Black, Color.Red);
float fMax = -float.MaxValue;
int nMaxIdx = 0;
float fMin1 = m_rgOverlay.Min(p => p);
float fMax1 = m_rgOverlay.Max(p => p);
for (int i = 0; i < m_rgOverlay.Length; i++)
{
if (fMin1 < 0 || fMax1 > 1)
{
m_rgOverlay[i] = (m_rgOverlay[i] - fMin1) / (fMax1 - fMin1);
}
if (m_rgOverlay[i] > fMax)
{
fMax = m_rgOverlay[i];
nMaxIdx = i;
}
}
for (int i = 0; i < m_rgOverlay.Length; i++)
{
drawProbabilities(g, nX, nY, nWid1, nHt1, i, m_rgOverlay[i], fMin1, fMax1, clrMap.GetColor(i + 1), (i == nMaxIdx) ? true : false);
nX += nWid1;
}
}
}
public void Should_Convert_To_List_Of_Dto()
{
var colors = new Domain.Entities.Color[]
{
Domain.Entities.Color.New("test 1", StatusEnum.Enable, TenantId.New()),
Domain.Entities.Color.New("test 2", StatusEnum.Enable, TenantId.New())
};
var dtos = ColorMapper.Map(colors).ToList();
Assert.NotEmpty(dtos);
Assert.NotNull(dtos);
}
void initSurface()
{
mMapper = new MyMapper();
//color map ~ independent on range
var colors = new ColorMapRainbow();
colors.Direction = true;
mColorMap = new ColorMapper(colors, -3, 9, new Color(1, 1, 1, 0.8));
setupSurface();
}
public async Task <IPagination <ColorQueryDto> > Handle(ListColorQueryRequest request, CancellationToken cancellationToken)
{
var pagination = await _colorRepository.ListAsync(request.Filter, request.OrderBy, request.Page, request.QtyPerPage);
if (pagination.IsEmpty())
{
return(Pagination <ColorQueryDto> .Empty);
}
var colorDtos = ColorMapper.Map(pagination.Entities);
var paginationDto = Pagination <ColorQueryDto> .New(colorDtos, pagination.TotalPages, pagination.ItemsPerPage, pagination.CurrentPage);
return(paginationDto);
}
private void overlay(Bitmap bmp, double[][] rgData)
{
if (bmp == null)
{
return;
}
using (Graphics g = Graphics.FromImage(bmp))
{
int nBorder = 30;
int nWid = bmp.Width - (nBorder * 2);
int nWid1 = nWid / rgData.Length;
int nHt1 = (int)(bmp.Height * 0.3);
int nX = nBorder;
int nY = bmp.Height - nHt1;
ColorMapper clrMap = new ColorMapper(0, rgData.Length + 1, Color.Black, Color.Red);
float[] rgfMin = new float[rgData.Length];
float[] rgfMax = new float[rgData.Length];
float fMax = -float.MaxValue;
float fMaxMax = -float.MaxValue;
int nMaxIdx = 0;
for (int i = 0; i < rgData.Length; i++)
{
rgfMin[i] = (float)rgData[i].Min(p => p);
rgfMax[i] = (float)rgData[i].Max(p => p);
if (rgfMax[i] > fMax)
{
fMax = rgfMax[i];
nMaxIdx = i;
}
fMaxMax = Math.Max(fMax, fMaxMax);
}
if (fMaxMax > 0.2f)
{
m_bNormalizeOverlay = false;
}
for (int i = 0; i < rgData.Length; i++)
{
drawProbabilities(g, nX, nY, nWid1, nHt1, i, rgData[i], clrMap.GetColor(i + 1), rgfMin.Min(p => p), rgfMax.Max(p => p), (i == nMaxIdx) ? true : false, m_bNormalizeOverlay);
nX += nWid1;
}
}
}
private void FillRegion(
Region region,
LockableBitmap lockableBitmap)
{
Color color;
if (!ColorMapper.TryMap(region.Number, out color))
{
color = colorGenerator.RandomColor();
}
foreach (ScanInfo info in region.Infos)
{
lockableBitmap.SetPixel(info.Coords.X, info.Coords.Y, color);
}
}
private void FillRegion(
int regionIndex,
KeyValuePair <int, List <ScanInfo> > region,
LockableBitmap lockableBitmap)
{
Color color;
if (!ColorMapper.TryMap(regionIndex, out color))
{
color = colorGenerator.RandomColor();
}
foreach (ScanInfo info in region.Value)
{
lockableBitmap.SetPixel(info.Coords.X, info.Coords.Y, color);
}
}
Color getColor(double dfVal, ColorMapper mapper, bool bBinary)
{
Color clr = Color.Black;
if (bBinary)
{
if (dfVal != 0)
{
clr = Color.White;
}
}
else
{
clr = mapper.GetColor(dfVal);
}
return(clr);
}
private IEnumerable <ImageDisplay.OverlayRect> GetOverlays(Image data, ColorMapper stringToColor)
{
using (var disposer = new EnumerableDisposer <Box>(data.Boxes))
{
var boxes = disposer.Collection.ToArray();
var temp = new ImageDisplay.OverlayRect[boxes.Length];
for (var i = 0; i < temp.Length; ++i)
{
temp[i] = new ImageDisplay.OverlayRect();
temp[i].Rect = boxes[i].Rect;
temp[i].Label = boxes[i].Label;
temp[i].Parts = boxes[i].Parts;
temp[i].CrossedOut = boxes[i].Ignore;
temp[i].Color = stringToColor.Operator(boxes[i].Label);
}
return(temp);
}
}
public object getSquarePolygonsAroundCoordinates(ColorMapper cmap, Color colorFactor)
{
List <Polygon> polygons = new List <Polygon>();
for (int xi = 0; xi <= x.Length - 2; xi++)
{
for (int yi = 0; yi <= y.Length - 2; yi++)
{
// Compute quad making a polygon
Point[] p = getEstimatedQuadSurroundingPoint(xi, yi);
if ((!validZ(p)))
{
continue;
// ignore non valid set of points
}
if (((cmap != null)))
{
p[0].Color = cmap.Color(p[0].xyz);
p[1].Color = cmap.Color(p[1].xyz);
p[2].Color = cmap.Color(p[2].xyz);
p[3].Color = cmap.Color(p[3].xyz);
}
if (((colorFactor != null)))
{
p[0].rgb.mul(colorFactor);
p[1].rgb.mul(colorFactor);
p[2].rgb.mul(colorFactor);
p[3].rgb.mul(colorFactor);
}
// Store quad
Polygon quad = new Polygon();
for (int pi = 0; pi <= p.Length - 1; pi++)
{
quad.Add(p[pi]);
}
polygons.Add(quad);
}
}
return(polygons);
}
public void MapColor_ThrowsException_WhenCalledAndConsoleWindowIsntOpen()
{
ColorMapper mapper = new ColorMapper();
Assert.Throws <ColorMappingException>(() => mapper.MapColor(ColorStoreTests.TEST_CONSOLE_COLOR, ColorStoreTests.TEST_COLOR));
}
Bitmap createImage(List <double> rgVal, int nSize, int nCellSize, bool bBinary)
{
Dictionary <Color, Brush> rgBrushes = new Dictionary <Color, Brush>();
ColorMapper mapper = null;
Bitmap bmp = new Bitmap(nSize * nCellSize, nSize * nCellSize);
int nIdx = 0;
if (!bBinary)
{
double dfMin = rgVal.Min(p => p);
double dfMax = rgVal.Max(p => p);
mapper = new ColorMapper(dfMin, dfMax, Color.Black, Color.Fuchsia);
}
using (Graphics g = Graphics.FromImage(bmp))
{
g.FillRectangle(Brushes.Black, new Rectangle(0, 0, bmp.Width, bmp.Height));
if (nCellSize > 1)
{
for (int y = 0; y < nSize; y++)
{
for (int x = 0; x < nSize; x++)
{
if (nIdx < rgVal.Count)
{
Color clr = getColor(rgVal[nIdx], mapper, bBinary);
Rectangle rcCell = new Rectangle(x * nCellSize, y * nCellSize, nCellSize, nCellSize);
if (!rgBrushes.ContainsKey(clr))
{
rgBrushes.Add(clr, new SolidBrush(clr));
}
g.FillRectangle(rgBrushes[clr], rcCell);
nIdx++;
}
}
}
}
}
if (nCellSize == 1)
{
for (int y = 0; y < nSize; y++)
{
for (int x = 0; x < nSize; x++)
{
if (nIdx < rgVal.Count)
{
Color clr = getColor(rgVal[nIdx], mapper, bBinary);
bmp.SetPixel(x, y, clr);
nIdx++;
}
}
}
}
foreach (KeyValuePair <Color, Brush> val in rgBrushes)
{
val.Value.Dispose();
}
return(bmp);
}
public Color ToRgb()
{
return(ColorMapper.MapAgsColourNumberToRgbColor(_agsColorNumber));
}
public ColorbarImageGenerator(ColorMapper mapper, ITickProvider provider, ITickRenderer renderer)
: this(mapper.ColorMap, (float)mapper.ZMin, (float)mapper.ZMax, provider, renderer)
{
}
public static Shape buildRing(OrthonormalGrid grid, Mapper mapper, float ringMin, float ringMax, ColorMapper cmap, Color factor)
{
RingTessellator tesselator = new RingTessellator(ringMin, ringMax, cmap, factor);
return((Shape)tesselator.build(grid.Apply(mapper)));
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="fL">Specifies the left position.</param>
/// <param name="fR">Specifies the right position.</param>
/// <param name="fT">Specifies the top position.</param>
/// <param name="fB">Specifies the bottom position.</param>
/// <param name="clrFill">Specifies the fill color.</param>
/// <param name="clrBorder">Specifies the border color.</param>
/// <param name="clrMap">Optionally, specifies a color-map used to color the rectangle based on the x position of the object.</param>
public GeomRectangle(float fL, float fR, float fT, float fB, Color clrFill, Color clrBorder, ColorMapper clrMap = null)
: base(fL, fR, fT, fB, clrFill, clrBorder)
{
m_clrMap = clrMap;
}
/// <summary>
/// Render the gyms specified data.
/// </summary>
/// <param name="bShowUi">When <i>true</i> the Bitmap is drawn.</param>
/// <param name="nWidth">Specifies the width used to size the Bitmap.</param>
/// <param name="nHeight">Specifies the height used to size the Bitmap.</param>
/// <param name="rgData">Specifies the gym data to render.</param>
/// <param name="bGetAction">When <i>true</i> the action data is returned as a SimpleDatum.</param>
/// <returns>A tuple optionally containing a Bitmap and/or Simpledatum is returned.</returns>
public Tuple <Bitmap, SimpleDatum> Render(bool bShowUi, int nWidth, int nHeight, double[] rgData, bool bGetAction)
{
Bitmap bmp = new Bitmap(nWidth, nHeight);
double dfX = rgData[0];
double dfTheta = rgData[2];
double dfThetaInDegrees = dfTheta * (180.0 / Math.PI);
double dfForceMag = rgData[4];
int nSteps = (int)rgData[5];
m_nSteps = nSteps;
m_nMaxSteps = Math.Max(nSteps, m_nMaxSteps);
using (Graphics g = Graphics.FromImage(bmp))
{
Rectangle rc = new Rectangle(0, 0, bmp.Width, bmp.Height);
g.FillRectangle(Brushes.White, rc);
float fScreenWidth = g.VisibleClipBounds.Width;
float fScreenHeight = g.VisibleClipBounds.Height;
float fWorldWidth = (float)(m_dfXThreshold * 2);
float fScale = fScreenWidth / fWorldWidth;
float fCartY = 100; // Top of Cart;
float fPoleWidth = 10;
float fPoleLen = fScale * 1.0f;
float fCartWidth = 50;
float fCartHeight = 30;
float fL = -fCartWidth / 2;
float fR = fCartWidth / 2;
float fT = fCartHeight / 2;
float fB = -fCartHeight / 2;
float fAxleOffset = 0;
GeomCart cart = new GeomCart(fL, fR, fT, fB, Color.SkyBlue, Color.Black);
fL = -fPoleWidth / 2;
fR = fPoleWidth / 2;
fT = fPoleLen - fPoleWidth / 2;
fB = --fPoleWidth / 2;
GeomPole pole = new GeomPole(fL, fR, fT, fB, Color.Tan, Color.Black);
fL = 0;
fR = fScreenWidth;
fT = fCartY;
fB = fT;
GeomLine track = new GeomLine(fL, fR, fT, fB, Color.Black, Color.Black);
fL = 0;
fR = fScreenWidth;
fT = fCartY - 40;
fB = fT + 10;
if (m_clrMap == null)
{
m_clrMap = new ColorMapper(fL, fR, Color.Fuchsia, Color.Red);
}
GeomRectangle posbar = new GeomRectangle(fL, fR, fT, fB, Color.Black, Color.Transparent, m_clrMap);
float fCartX = (float)dfX * fScale + fScreenWidth / 2; // middle of the cart.
cart.SetLocation(fCartX, fCartY);
pole.SetRotation((float)-dfThetaInDegrees);
cart.Attach(pole, fAxleOffset);
GeomView view = new GeomView();
view.RenderText(g, "Current Force = " + dfForceMag.ToString(), 10, 10);
view.RenderText(g, "X = " + dfX.ToString("N02"), 10, 24);
view.RenderText(g, "Theta = " + dfTheta.ToString("N02") + " radians", 10, 36);
view.RenderText(g, "Theta = " + dfThetaInDegrees.ToString("N02") + " degrees", 10, 48);
view.RenderSteps(g, m_nSteps, m_nMaxSteps);
// Render the objects.
view.AddObject(posbar);
view.AddObject(track);
view.AddObject(cart);
view.Render(g);
SimpleDatum sdAction = null;
if (bGetAction)
{
sdAction = getActionData(fCartX, fCartY, bmp);
}
m_bmp = bmp;
return(new Tuple <Bitmap, SimpleDatum>(bmp, sdAction));
}
}
public void MapColor_ThrowsException_WhenCalledAndConsoleWindowIsntOpen()
{
ColorMapper mapper = new ColorMapper();
Assert.Throws<ColorMappingException>(() => mapper.MapColor(ColorStoreTests.TEST_CONSOLE_COLOR, ColorStoreTests.TEST_COLOR));
}
