// Update is called once per frame
void Update()
{
Vector3 UL_Pos = camera.WorldToScreenPoint(upperLeft.position);
Vector3 BR_Pos = camera.WorldToScreenPoint(bottomRight.position);
Vector3 diff;
diff.x = UL_Pos.x - BR_Pos.x;
diff.y = UL_Pos.y - BR_Pos.y;
// Get fingerTips and Image to apply as texture on planes
Coordinate[] fingertips = GetComponent<Plugin_Handler>().fingertips;
capture_resolution = GetComponent<Plugin_Handler>().capture_resolution;
for(int i=0; i<5; i++)
{
sphere_screen_pos[i].x = BR_Pos.x + (diff.x * fingertips[i].x / capture_resolution.width);;
sphere_screen_pos[i].y = BR_Pos.y + (diff.y * fingertips[i].y / capture_resolution.height);
sphere_screen_pos[i].z = UL_Pos.z - 5; // subtraction only added for testing
try
{
// the place where the sphere will be positioned
sphere_world_pos[i] = camera.ScreenToWorldPoint(sphere_screen_pos[i]);
}
catch (UnityException e)
{
print("cannot make world point from screen point " + e);
}
}
}
public static void Run()
{
// ExStart:ConvertPageRegionToDOM
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open document
Document document = new Document( dataDir + "AddImage.pdf");
// Get rectangle of particular page region
Aspose.Pdf.Rectangle pageRect = new Aspose.Pdf.Rectangle(20, 671, 693, 1125);
// Set CropBox value as per rectangle of desired page region
document.Pages[1].CropBox = pageRect;
// Save cropped document into stream
MemoryStream ms = new MemoryStream();
document.Save(ms);
// Open cropped PDF document and convert to image
document = new Document(ms);
// Create Resolution object
Resolution resolution = new Resolution(300);
// Create PNG device with specified attributes
PngDevice pngDevice = new PngDevice(resolution);
dataDir = dataDir + "ConvertPageRegionToDOM_out.png";
// Convert a particular page and save the image to stream
pngDevice.Process(document.Pages[1], dataDir);
ms.Close();
// ExEnd:ConvertPageRegionToDOM
Console.WriteLine("\nPage region converted to DOM successfully.\nFile saved at " + dataDir);
}
private void SetupPageSize(WIA.Item item, PageSize pageSize, ColorDepth colorDepth, Resolution resolution, Orientation orientation, bool setSize)
{
if (item == null)
return;
item.Properties["Horizontal Resolution"].set_Value(resolution.Value);
item.Properties["Vertical Resolution"].set_Value(resolution.Value);
item.Properties["Current Intent"].set_Value(colorDepth.Value);
item.Properties["Bits Per Pixel"].set_Value(colorDepth.BitsPerPixel);
double hExtent = item.Properties["Horizontal Extent"].SubTypeMax;
double vExtent = item.Properties["Vertical Extent"].SubTypeMax;
if (setSize)
{
if (orientation.Direction == 0)
{
item.Properties["Horizontal Extent"].set_Value(resolution.Value * pageSize.Width);
item.Properties["Vertical Extent"].set_Value(resolution.Value * pageSize.Height);
}
else
{
item.Properties["Horizontal Extent"].set_Value(resolution.Value * pageSize.Height);
item.Properties["Vertical Extent"].set_Value(resolution.Value * pageSize.Width);
}
}
else
{
item.Properties["Horizontal Extent"].set_Value(hExtent);
item.Properties["Vertical Extent"].set_Value(vExtent);
}
}
public static void Run()
{
// ExStart:AllPagesToTIFF
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open document
Document pdfDocument = new Document(dataDir+ "PageToTIFF.pdf");
// Create Resolution object
Resolution resolution = new Resolution(300);
// Create TiffSettings object
TiffSettings tiffSettings = new TiffSettings();
tiffSettings.Compression = CompressionType.None;
tiffSettings.Depth = ColorDepth.Default;
tiffSettings.Shape = ShapeType.Landscape;
tiffSettings.SkipBlankPages = false;
// Create TIFF device
TiffDevice tiffDevice = new TiffDevice(resolution, tiffSettings);
// Convert a particular page and save the image to stream
tiffDevice.Process(pdfDocument, dataDir + "AllPagesToTIFF_out.tif");
// ExEnd:AllPagesToTIFF
System.Console.WriteLine("PDF all pages converted to one tiff file successfully!");
}
/********************************************************
* CONSTRUCTOR/DELEGATE DEFINITIONS
*********************************************************/
/// <summary>
/// Construct the Market Vehicle
/// </summary>
public Security(string symbol, SecurityType type, Resolution resolution, bool fillDataForward, decimal leverage, bool extendedMarketHours, bool useQuantConnectData = false)
{
//Set Basics:
this._symbol = symbol;
this._type = type;
this._resolution = resolution;
this._isFillDataForward = fillDataForward;
this._leverage = leverage;
this._isExtendedMarketHours = extendedMarketHours;
this._isQuantConnectData = useQuantConnectData;
//Setup Transaction Model for this Asset
switch (type)
{
case SecurityType.Equity:
Model = new EquityTransactionModel();
break;
case SecurityType.Forex:
Model = new ForexTransactionModel();
break;
case SecurityType.Base:
Model = new SecurityTransactionModel();
break;
}
//Holdings for new Vehicle:
Cache = new SecurityCache();
Holdings = new SecurityHolding(symbol, Model);
Exchange = new SecurityExchange();
}
/********************************************************
* CONSTRUCTOR/DELEGATE DEFINITIONS
*********************************************************/
/// <summary>
/// Construct the Market Vehicle
/// </summary>
public Security(string symbol, SecurityType type, Resolution resolution, bool fillDataForward, decimal leverage, bool extendedMarketHours)
{
//Set Basics:
this._symbol = symbol;
this._type = type;
this._resolution = resolution;
this._isFillDataForward = fillDataForward;
this._leverage = leverage;
this._isExtendedMarketHours = extendedMarketHours;
//Holdings for new Vehicle:
Cache = new SecurityCache();
Holdings = new SecurityHolding(symbol, Model);
Exchange = new SecurityExchange();
//Cannot initalise a default model.
Model = null;
//Set data type:
if (resolution == Resolution.Minute || resolution == Resolution.Second) {
_dataType = typeof(TradeBar);
} else {
_dataType = typeof(Tick);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HistoryRequest"/> class from the specified parameters
/// </summary>
/// <param name="startTimeUtc">The start time for this request,</param>
/// <param name="endTimeUtc">The start time for this request</param>
/// <param name="dataType">The data type of the output data</param>
/// <param name="symbol">The symbol to request data for</param>
/// <param name="securityType">The security type of the symbol</param>
/// <param name="resolution">The requested data resolution</param>
/// <param name="market">The market this data belongs to</param>
/// <param name="exchangeHours">The exchange hours used in fill forward processing</param>
/// <param name="fillForwardResolution">The requested fill forward resolution for this request</param>
/// <param name="includeExtendedMarketHours">True to include data from pre/post market hours</param>
/// <param name="isCustomData">True for custom user data, false for normal QC data</param>
public HistoryRequest(DateTime startTimeUtc,
DateTime endTimeUtc,
Type dataType,
Symbol symbol,
SecurityType securityType,
Resolution resolution,
string market,
SecurityExchangeHours exchangeHours,
Resolution? fillForwardResolution,
bool includeExtendedMarketHours,
bool isCustomData
)
{
StartTimeUtc = startTimeUtc;
EndTimeUtc = endTimeUtc;
Symbol = symbol;
ExchangeHours = exchangeHours;
Resolution = resolution;
FillForwardResolution = fillForwardResolution;
IncludeExtendedMarketHours = includeExtendedMarketHours;
DataType = dataType;
SecurityType = securityType;
Market = market;
IsCustomData = isCustomData;
TimeZone = exchangeHours.TimeZone;
}
public static void Run()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_Images();
//Open document
Document pdfDocument = new Document(dataDir+ "PageToTIFF.pdf");
//Create Resolution object
Resolution resolution = new Resolution(300);
//Create TiffSettings object
TiffSettings tiffSettings = new TiffSettings();
tiffSettings.Compression = CompressionType.None;
tiffSettings.Depth = ColorDepth.Default;
tiffSettings.Shape = ShapeType.Landscape;
tiffSettings.SkipBlankPages = false;
//Create TIFF device
TiffDevice tiffDevice = new TiffDevice(resolution, tiffSettings);
//Convert a particular page and save the image to stream
tiffDevice.Process(pdfDocument, 1, 1, dataDir + "output.tif");
}
/// <summary>
/// Determines if we can add a subscription for the specified resolution
/// </summary>
/// <param name="resolution">The new subscription resolution to check</param>
/// <param name="reason">When this function returns false, this is the reason we are unable to add the subscription</param>
/// <returns>True if we can add a subscription for the specified resolution while
/// remaining within our limits, false if this will put us over our limits</returns>
public bool CanAddSubscription(Resolution resolution, out string reason)
{
reason = null;
var limit = GetResolutionLimit(resolution);
// we increment the resolution since we're about to add one
var count = GetResolutionCount(resolution) + 1;
// check max counts of symbols
if (count >= limit)
{
reason = GetCountLimitReason(resolution);
return false;
}
// check ram usage
var ramEstimate = GetRamEstimate(
GetResolutionCount(Resolution.Minute),
GetResolutionCount(Resolution.Second),
GetResolutionCount(Resolution.Tick)
);
// finally, check current estimate against the precomputed maximum
if (ramEstimate > _maxRamEstimate)
{
reason = GetMaxRamReason(ramEstimate);
return false;
}
return true;
}
private void SetResolution()
{
Dropdown dropdown = GetComponent<Dropdown> ();
PossibleResolutions = Screen.resolutions;
foreach (Resolution res in PossibleResolutions) {
dropdown.options.Add (new Dropdown.OptionData () { text = res.width + " x " + res.height });
}
Resolution currentRes;
if(PlayerPrefs.GetInt("windowed_mode") == 1) {
currentRes = new Resolution () {
width = Screen.currentResolution.width,
height = Screen.currentResolution.height
};
} else {
currentRes = new Resolution () {
width = Screen.width,
height = Screen.height
};
}
dropdown.value = Array.IndexOf (PossibleResolutions, currentRes);
dropdown.onValueChanged.AddListener ((index) => {
PlayerPrefs.SetInt("screen_width", PossibleResolutions[index].width);
PlayerPrefs.SetInt("screen_height", PossibleResolutions[index].height);
Screen.SetResolution(PlayerPrefs.GetInt("screen_width"), PlayerPrefs.GetInt("screen_height"), Screen.fullScreen);
});
}
private void SetResolution(Resolution hibResolution)
{
switch (hibResolution)
{
case Resolution.Year:
resolution = DateTools.Resolution.YEAR;
break;
case Resolution.Month:
resolution = DateTools.Resolution.MONTH;
break;
case Resolution.Day:
resolution = DateTools.Resolution.DAY;
break;
case Resolution.Hour:
resolution = DateTools.Resolution.HOUR;
break;
case Resolution.Minute:
resolution = DateTools.Resolution.MINUTE;
break;
case Resolution.Second:
resolution = DateTools.Resolution.SECOND;
break;
case Resolution.Millisecond:
resolution = DateTools.Resolution.MILLISECOND;
break;
default:
throw new AssertionFailure("Unknown Resolution: " + hibResolution);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CsvDataProcessor"/> class
/// </summary>
/// <param name="dataDirectory">The root data directory, /Data</param>
/// <param name="resolution">The resolution being sent into the Process method</param>
/// <param name="tickType">The tick type, trade or quote</param>
public CsvDataProcessor(string dataDirectory, Resolution resolution, TickType tickType)
{
_dataDirectory = dataDirectory;
_resolution = resolution;
_tickType = tickType;
_writers = new Dictionary<Symbol, Writer>();
}
public override CurrentMenu Update(GameTime gametime, Inputhandler inputhandler)
{
CurrentMenu menu = CurrentMenu.Options;
base.DoUpDownMovement(gametime, inputhandler);
if (inputhandler.GetNewPressedMenuKeys.Contains(MenuKeys.Left) || inputhandler.GetNewPressedMenuKeys.Contains(MenuKeys.Right))
{
int relative = inputhandler.GetNewPressedMenuKeys.Contains(MenuKeys.Left) ? -1 : 1;
switch (current_position)
{
case (int)OptionsMenuPositions.Resolution:
tempRes = Resolution.GetAvailableResolutions.GetRelativeElement(currentResPos, relative);
try
{
currentResPos = Resolution.GetAvailableResolutions.IndexOf(tempRes);
}
catch (Exception)
{
currentResPos = 0;
}
break;
case (int)OptionsMenuPositions.Shader_Quality:
options.QualitySettings[OptionsID.ShaderQuality] = options.QualitySettings[OptionsID.ShaderQuality].GetRelativeElement(relative);
break;
case (int)OptionsMenuPositions.Post_Process_Quality:
options.QualitySettings[OptionsID.PostProcessQuality] = options.QualitySettings[OptionsID.PostProcessQuality].GetRelativeElement(relative);
break;
case (int)OptionsMenuPositions.Particle_Quality:
options.QualitySettings[OptionsID.ParticleQuality] = options.QualitySettings[OptionsID.ParticleQuality].GetRelativeElement(relative);
break;
case (int)OptionsMenuPositions.Controller:
options.Controller = options.Controller.GetRelativeElement(relative);
break;
case (int)OptionsMenuPositions.Display_Mode:
tempDisplayMode = options.DisplayMode.GetRelativeElement(relative);
break;
case (int)OptionsMenuPositions.Music_Volume:
options.MusicVolume = options.MusicVolume + relative * 5;
break;
}
RecreateStrings();
}
if (inputhandler.GetNewPressedMenuKeys.Contains(MenuKeys.Back))
menu = CurrentMenu.MainMenu;
if (inputhandler.GetNewPressedMenuKeys.Contains(MenuKeys.Enter))
{
switch (current_position)
{
case (int)OptionsMenuPositions.Back:
menu = CurrentMenu.MainMenu;
break;
case (int)OptionsMenuPositions.Apply:
options.DisplayMode = tempDisplayMode;
options.Resolution = tempRes;
RecreateStrings();
break;
}
}
return menu;
}
/// <summary>
/// Creates a new <see cref="Indicators.CandlestickPatterns.ThreeBlackCrows"/> pattern indicator.
/// The indicator will be automatically updated on the given resolution.
/// </summary>
/// <param name="symbol">The symbol whose pattern we seek</param>
/// <param name="resolution">The resolution.</param>
/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>
/// <returns>The pattern indicator for the requested symbol.</returns>
public ThreeBlackCrows ThreeBlackCrows(Symbol symbol, Resolution? resolution = null, Func<BaseData, TradeBar> selector = null)
{
var name = _algorithm.CreateIndicatorName(symbol, "THREEBLACKCROWS", resolution);
var pattern = new ThreeBlackCrows(name);
_algorithm.RegisterIndicator(symbol, pattern, resolution, selector);
return pattern;
}
/// <summary>
/// Creates a new <see cref="Indicators.CandlestickPatterns.ThreeInside"/> pattern indicator.
/// The indicator will be automatically updated on the given resolution.
/// </summary>
/// <param name="symbol">The symbol whose pattern we seek</param>
/// <param name="resolution">The resolution.</param>
/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>
/// <returns>The pattern indicator for the requested symbol.</returns>
public ThreeInside ThreeInside(Symbol symbol, Resolution? resolution = null, Func<BaseData, TradeBar> selector = null)
{
var name = _algorithm.CreateIndicatorName(symbol, "THREEINSIDE", resolution);
var pattern = new ThreeInside(name);
_algorithm.RegisterIndicator(symbol, pattern, resolution, selector);
return pattern;
}
public void CheckResolution()
{
currentResolution = Screen.currentResolution;
float w = currentResolution.width;
h = currentResolution.height;
ratio = w / h;
}
public CaptureManager(
Resolution resolution,
bool captureImages,
bool captureAudio,
bool captureVideo,
CameraType cameraType,
string movieRecordingDirectory,
int movieSegmentDurationInMilliSeconds,
bool breakMovieIntoSegments )
{
this.resolution = resolution;
this.captureImages = captureImages;
this.captureAudio = captureAudio;
this.captureVideo = captureVideo;
this.cameraType = cameraType;
this.movieSegmentDurationInMilliSeconds = movieSegmentDurationInMilliSeconds;
this.breakMovieIntoSegments = breakMovieIntoSegments;
if ( captureAudio || captureVideo )
{
this.movieRecordingDirectory = Path.Combine( movieRecordingDirectory, getDateTimeDirectoryName( DateTime.Now ) );
if ( Directory.Exists( this.movieRecordingDirectory ) == false )
{
Directory.CreateDirectory( this.movieRecordingDirectory );
}
}
}
public SphericalMercatorWorldSchema()
{
var resolutions = new[] {
156543.033900000, 78271.516950000, 39135.758475000, 19567.879237500,
9783.939618750, 4891.969809375, 2445.984904688, 1222.992452344,
611.496226172, 305.748113086, 152.874056543, 76.437028271,
38.218514136, 19.109257068, 9.554628534, 4.777314267,
2.388657133, 1.194328567, 0.597164283};
var count = 0;
foreach (var resolution in resolutions)
{
Resolutions[count] = new Resolution {Id = count.ToString(CultureInfo.InvariantCulture), UnitsPerPixel = resolution};
count++;
}
Height = 256;
Width = 256;
Extent = new Extent(-20037508.342789, -20037508.342789, 20037508.342789, 20037508.342789);
OriginX = -20037508.342789;
OriginY = -20037508.342789;
Name = "WorldSphericalMercator";
Format = "png";
Axis = AxisDirection.Normal;
Srs = "EPSG:3857";
}
public static void Run()
{
// ExStart:ConvertAllPagesToPNG
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open document
Document pdfDocument = new Document(dataDir + "ConvertAllPagesToPNG.pdf");
for (int pageCount = 1; pageCount <= pdfDocument.Pages.Count; pageCount++)
{
using (FileStream imageStream = new FileStream(dataDir + "image" + pageCount + "_out" + ".png", FileMode.Create))
{
// Create PNG device with specified attributes
// Width, Height, Resolution, Quality
// Quality [0-100], 100 is Maximum
// Create Resolution object
Resolution resolution = new Resolution(300);
PngDevice pngDevice = new PngDevice(resolution);
// Convert a particular page and save the image to stream
pngDevice.Process(pdfDocument.Pages[pageCount], imageStream);
// Close stream
imageStream.Close();
}
}
// ExEnd:ConvertAllPagesToPNG
System.Console.WriteLine("PDF pages are converted to PNG successfully!");
}
/// <summary>
/// Creates a new <see cref="Indicators.CandlestickPatterns.TwoCrows"/> pattern indicator.
/// The indicator will be automatically updated on the given resolution.
/// </summary>
/// <param name="symbol">The symbol whose pattern we seek</param>
/// <param name="resolution">The resolution.</param>
/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>
/// <returns>The pattern indicator for the requested symbol.</returns>
public TwoCrows TwoCrows(Symbol symbol, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)
{
var name = _algorithm.CreateIndicatorName(symbol, "TWOCROWS", resolution);
var pattern = new TwoCrows(name);
_algorithm.RegisterIndicator(symbol, pattern, resolution, selector);
return pattern;
}
public static void Main(string[] args)
{
// The path to the documents directory.
string dataDir = Path.GetFullPath("../../../Data/");
//open document
Document pdfDocument = new Document(dataDir + "input.pdf");
for (int pageCount = 1; pageCount <= pdfDocument.Pages.Count; pageCount++)
{
using (FileStream imageStream = new FileStream(dataDir + "image" + pageCount + ".jpg", FileMode.Create))
{
//create JPEG device with specified attributes
//Width, Height, Resolution, Quality
//Quality [0-100], 100 is Maximum
//create Resolution object
Resolution resolution = new Resolution(300);
//JpegDevice jpegDevice = new JpegDevice(500, 700, resolution, 100);
JpegDevice jpegDevice = new JpegDevice(resolution, 100);
//convert a particular page and save the image to stream
jpegDevice.Process(pdfDocument.Pages[pageCount], imageStream);
//close stream
imageStream.Close();
}
}
System.Console.WriteLine("PDF pages are converted to individual images successfully!");
}
Resolution getScreenResolution()
{
Resolution resolution = new Resolution();
resolution.height = playerCamera.pixelHeight;
resolution.width = playerCamera.pixelWidth;
return resolution;
}
void Start()
{
instance = this;
// resolution
Resolution currentResolution = Screen.currentResolution;
if (Application.isEditor) {
screenResolution = Screen.resolutions [0];
} else {
screenResolution = currentResolution;
}
//set the resolution
Screen.SetResolution (screenResolution.width, screenResolution.height, true);
// UI Camera setup
UICamera = new GameObject ("UICamera");
UICamera.AddComponent<Camera>();
Camera uiCamera = UICamera.GetComponent<Camera>();
uiCamera.cullingMask = uiCameraLayerMask;
uiCamera.name = "UICamera";
uiCamera.orthographicSize = screenResolution.height / 2;
uiCamera.orthographic = true;
uiCamera.nearClipPlane = 0.3f;
uiCamera.farClipPlane = 50f;
uiCamera.clearFlags = CameraClearFlags.Depth;
uiCamera.depth = 1;
uiCamera.rect = new Rect (0, 0, 1, 1);
uiCamera.renderingPath = RenderingPath.UsePlayerSettings;
uiCamera.targetTexture = null;
uiCamera.hdr = false;
}
/********************************************************
* CLASS CONSTRUCTOR
*********************************************************/
/// <summary>
/// Constructor for Data Subscriptions
/// </summary>
/// <param name="objectType">Type of the data objects.</param>
/// <param name="securityType">SecurityType Enum Set Equity/FOREX/Futures etc.</param>
/// <param name="symbol">Symbol of the asset we're requesting</param>
/// <param name="resolution">Resolution of the asset we're requesting</param>
/// <param name="fillForward">Fill in gaps with historical data</param>
/// <param name="extendedHours">Equities only - send in data from 4am - 8pm</param>
public SubscriptionDataConfig(Type objectType, SecurityType securityType = SecurityType.Equity, string symbol = "", Resolution resolution = Resolution.Minute, bool fillForward = true, bool extendedHours = false)
{
this.Type = objectType;
this.Security = securityType;
this.Resolution = resolution;
this.Symbol = symbol;
this.FillDataForward = fillForward;
this.ExtendedMarketHours = extendedHours;
this.PriceScaleFactor = 1;
this.MappedSymbol = symbol;
switch (resolution)
{
case Resolution.Tick:
Increment = TimeSpan.FromSeconds(0);
break;
case Resolution.Second:
Increment = TimeSpan.FromSeconds(1);
break;
default:
case Resolution.Minute:
Increment = TimeSpan.FromMinutes(1);
break;
case Resolution.Hour:
Increment = TimeSpan.FromHours(1);
break;
case Resolution.Daily:
Increment = TimeSpan.FromDays(1);
break;
}
}
public static void Run()
{
// ExStart:ConvertToBMP
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_Images();
// Open document
Document pdfDocument = new Document(dataDir + "AddImage.pdf");
for (int pageCount = 1; pageCount <= pdfDocument.Pages.Count; pageCount++)
{
using (FileStream imageStream = new FileStream("image" + pageCount + "_out" + ".bmp", FileMode.Create))
{
// Create Resolution object
Resolution resolution = new Resolution(300);
// Create BMP device with specified attributes
// Width, Height, Resolution, PageSize
BmpDevice bmpDevice = new BmpDevice(resolution);
// Convert a particular page and save the image to stream
bmpDevice.Process(pdfDocument.Pages[pageCount], imageStream);
// Close stream
imageStream.Close();
}
}
// ExEnd:ConvertToBMP
Console.WriteLine("\nPDF file converted to bmp successfully!");
}
public void InsertIntoList(ref Resolution[] VariableList, int Index, Resolution[] Target, out int ListCount)
{
List<Resolution> list = new List<Resolution>(VariableList);
if (Index < 0) {
Index = 0;
}
if (list.Count == 0) {
foreach (Resolution tmpVar in Target)
{
list.Add(tmpVar);
}
} else {
if (Index + 1 >= list.Count) {
foreach (Resolution tmpVar in Target)
{
list.Add(tmpVar);
}
} else {
foreach (Resolution tmpVar in Target)
{
list.Insert(Index, tmpVar);
}
}
}
VariableList = list.ToArray();
ListCount = VariableList.Length;
}
/********************************************************
* CONSTRUCTOR/DELEGATE DEFINITIONS
*********************************************************/
/// <summary>
/// Construct a new security vehicle based on the user options.
/// </summary>
public Security(string symbol, SecurityType type, Resolution resolution, bool fillDataForward, decimal leverage, bool extendedMarketHours, bool isDynamicallyLoadedData = false)
{
//Set Basics:
_symbol = symbol;
_type = type;
_resolution = resolution;
_isFillDataForward = fillDataForward;
_leverage = leverage;
_isExtendedMarketHours = extendedMarketHours;
_isDynamicallyLoadedData = isDynamicallyLoadedData;
//Setup Transaction Model for this Asset
switch (type)
{
case SecurityType.Equity:
Model = new EquityTransactionModel();
DataFilter = new EquityDataFilter();
break;
case SecurityType.Forex:
Model = new ForexTransactionModel();
DataFilter = new ForexDataFilter();
break;
case SecurityType.Base:
Model = new SecurityTransactionModel();
DataFilter = new SecurityDataFilter();
break;
}
//Holdings for new Vehicle:
Cache = new SecurityCache();
Holdings = new SecurityHolding(symbol, type, Model);
Exchange = new SecurityExchange();
}
/// <summary>
/// Efetua a conversão do PDF em imagens
/// </summary>
/// <param name="pdfPath">Caminho do PDF</param>
/// <returns>Lista de caminhos das imagens por página</returns>
public List<string> Convert(string pdfPath)
{
List<string> imagePaths = new List<string>();
Document pdfDocument = new Document(pdfPath);
for (int pageCount = 1; pageCount <= pdfDocument.Pages.Count; pageCount++)
{
var imagePath = Path.Combine(Path.GetDirectoryName(pdfPath), "image" + pageCount + ".jpg");
using (FileStream imageStream = new FileStream(imagePath, FileMode.Create))
{
// Create Resolution object
Resolution resolution = new Resolution(300);
// Create JPEG device with specified attributes (Width, Height, Resolution, Quality)
// where Quality [0-100], 100 is Maximum
JpegDevice jpegDevice = new JpegDevice(resolution, 100);
// Convert a particular page and save the image to stream
jpegDevice.Process(pdfDocument.Pages[pageCount], imageStream);
// Close stream
imageStream.Close();
}
imagePaths.Add(imagePath);
}
return imagePaths;
}
public static void Run()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_Images();
//open document
Document pdfDocument = new Document(dataDir+ "ConvertAllPagesToEMF.pdf");
for (int pageCount = 1; pageCount <= pdfDocument.Pages.Count; pageCount++)
{
using (FileStream imageStream = new FileStream(dataDir + "image" + pageCount + ".emf", FileMode.Create))
{
//create Resolution object
Resolution resolution = new Resolution(300);
//create PNG device with specified attributes
//Width, Height, Resolution
EmfDevice emfDevice = new EmfDevice(500, 700, resolution);
//convert a particular page and save the image to stream
emfDevice.Process(pdfDocument.Pages[pageCount], imageStream);
//close stream
imageStream.Close();
}
}
}
public static void Run()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_Images();
//open document
Document pdfDocument = new Document(dataDir + "PageToPNG.pdf");
using (FileStream imageStream = new FileStream(dataDir + "aspose-logo.png", FileMode.Create))
{
//create Resolution object
Resolution resolution = new Resolution(300);
//create PNG device with specified attributes (Width, Height, Resolution)
PngDevice pngDevice = new PngDevice(resolution);
//convert a particular page and save the image to stream
pngDevice.Process(pdfDocument.Pages[1], imageStream);
//close stream
imageStream.Close();
}
}
public bool Equals(Resolution other)
{
return(other.Width == Width && other.Height == Height);
}
public void SetResolution(int resolutionIndex)
{
Resolution resolution = resolutions[resolutionIndex];
Screen.SetResolution(resolution.width, resolution.height, Screen.fullScreen);
}
/// <summary>
/// Sets the warm up period to the specified value
/// </summary>
/// <param name="timeSpan">The amount of time to warm up, this does not take into account market hours/weekends</param>
/// <param name="resolution">The resolution to request</param>
public void SetWarmUp(TimeSpan timeSpan, Resolution resolution)
{
SetWarmup(timeSpan, resolution);
}
/// <summary>
/// Sets the warm up period to the specified value
/// </summary>
/// <param name="timeSpan">The amount of time to warm up, this does not take into account market hours/weekends</param>
/// <param name="resolution">The resolution to request</param>
public void SetWarmup(TimeSpan timeSpan, Resolution resolution)
{
_warmupBarCount = null;
_warmupTimeSpan = timeSpan;
_warmupResolution = resolution;
}
/// <summary>
/// Sets the warm up period by resolving a start date that would send that amount of data into
/// the algorithm.
/// </summary>
/// <param name="barCount">The number of data points requested for warm up</param>
/// <param name="resolution">The resolution to request</param>
public void SetWarmUp(int barCount, Resolution resolution)
{
SetWarmup(barCount, resolution);
}
/// <summary>
/// Sets the warm up period by resolving a start date that would send that amount of data into
/// the algorithm.
/// </summary>
/// <param name="barCount">The number of data points requested for warm up</param>
/// <param name="resolution">The resolution to request</param>
public void SetWarmup(int barCount, Resolution resolution)
{
_warmupTimeSpan = null;
_warmupBarCount = barCount;
_warmupResolution = resolution;
}
public static void GetShaderArrays(out Texture2DArray texArray, out Matrix4x4[] worldToCameraMatrixArray, out Matrix4x4[] projectionMatrixArray)
{
string[] clippedTexFiles = Directory.GetFiles(Constants.Folders.ClippedRoomTextureFolderPath);
string[] cameraLocFiles = Directory.GetFiles(Constants.Folders.CameraLocationFolderPath);
Resolution camRes = Constants.Camera.CameraResolution();
Resolution downgradedRes = GetDowngradedResolution(camRes);
int numLegitimateTextureFiles = 0;
foreach (string texFile in clippedTexFiles)
{
string fileExtension = Path.GetExtension(texFile);
if (!fileExtension.Equals(Constants.Suffixes.FileSuffix_PNG) &&
!fileExtension.Equals(Constants.Suffixes.FileSuffix_JPG))
{
continue;
}
++numLegitimateTextureFiles;
}
if (clippedTexFiles.Length > 0)
{
texArray = new Texture2DArray(downgradedRes.width, downgradedRes.height, numLegitimateTextureFiles, Constants.Camera.Format, false);
}
else
{
texArray = null;
}
worldToCameraMatrixArray = new Matrix4x4[cameraLocFiles.Length];
projectionMatrixArray = new Matrix4x4[cameraLocFiles.Length];
int arrayIndex = 0;
foreach (string texFile in clippedTexFiles)
{
string fileExtension = Path.GetExtension(texFile);
if (!fileExtension.Equals(Constants.Suffixes.FileSuffix_PNG) &&
!fileExtension.Equals(Constants.Suffixes.FileSuffix_JPG))
{
continue;
}
// ERROR TESTING REMOVE
// Adjust the texture filepath to ready it for loading by Resources.Load, which requires a relative path with NO file extension
//string correctFilepath = Constants.Folders.ClippedRoomTextureFolderPath_Load + Path.GetFileNameWithoutExtension(texFile);
Texture2D tex = LoadTexture.Load(texFile);
Texture2D downgradedTex = DowngradeTexture(tex, downgradedRes);
// copy texture into texture array
texArray.SetPixels32(downgradedTex.GetPixels32(), arrayIndex);
// ERROR TESTING REMOVE
//Graphics.CopyTexture(downgradedTex, 0, 0, texArray, arrayIndex, 0);
CameraLocation camLoc = CameraLocation.Load(Constants.Folders.CameraLocationFolderPath + FileNameTranslator.ClippedTextureToCameraLocation(Path.GetFileNameWithoutExtension(texFile)) + Constants.Suffixes.FileSuffix_CameraLocation);
if (camLoc != null)
{
worldToCameraMatrixArray[arrayIndex] = camLoc.WorldToCameraTransform;
projectionMatrixArray[arrayIndex] = camLoc.ProjectionTransform;
}
++arrayIndex;
}
}
public void Assign(Resolution uValue)
{
Assign(uValue.width, uValue.height, uValue.refreshRate);
}
/// <summary>
/// Transforms the mouse position from screen coordinates to virtual coordinates.
/// </summary>
/// <param name="screenPos">The screen position.</param>
/// <returns>The screen position in virtual coordinates.</returns>
private Vector2 FromScreen(Vector2 screenPos)
{
// Correct the screen position by any viewport differences
var correctedPos = new Vector2(screenPos.X - Resolution.GetViewport().X, screenPos.Y - Resolution.GetViewport().Y);
// Now transform that position by the inverted matrix which is used for scaling the display. This way, the position will be scaled to the virtual screen size.
return(Vector2.Transform(correctedPos, Matrix.Invert(Resolution.getTransformationMatrix())));
}
public virtual void ChangedResolution(Resolution adaptedResolution)
{
}
public void should_parse_quality_from_other_source(string qualityString, Source source, Resolution resolution, Modifier modifier = Modifier.NONE)
{
foreach (var c in new char[] { '-', '.', ' ', '_' })
{
var title = string.Format("My series S01E01 {0}", qualityString.Replace(' ', c));
ParseAndVerifyQuality(title, source, false, resolution, modifier);
}
}
public SSResolution(Resolution uValue) : this()
{
Assign(uValue);
}
/// <summary>
/// Internal method to get the history for the given securities
/// </summary>
/// <param name="algorithm">Algorithm</param>
/// <param name="securities">Securities to get history for</param>
/// <param name="resolution">Resolution to retrieve data in</param>
/// <returns>History of the given securities</returns>
/// <remarks>Method is static because we want to use it from the constructor as well</remarks>
private static IEnumerable <Slice> GetHistory(IAlgorithm algorithm, List <Security> securities, Resolution resolution)
{
var historyRequests = new List <Data.HistoryRequest>();
// Create the history requests
foreach (var security in securities)
{
var historyRequestFactory = new HistoryRequestFactory(algorithm);
var configs = algorithm.SubscriptionManager
.SubscriptionDataConfigService
.GetSubscriptionDataConfigs(security.Symbol, includeInternalConfigs: true);
var startTime = historyRequestFactory.GetStartTimeAlgoTz(
security.Symbol,
1,
resolution,
security.Exchange.Hours);
var endTime = algorithm.EndDate;
// we need to order and select a specific configuration type
// so the conversion rate is deterministic
var configToUse = configs.OrderBy(x => x.TickType).First();
historyRequests.Add(historyRequestFactory.CreateHistoryRequest(
configToUse,
startTime,
endTime,
security.Exchange.Hours,
resolution
));
}
return(algorithm.HistoryProvider.GetHistory(historyRequests, algorithm.TimeZone).ToList());
}
public void GetsHistory(Symbol symbol, Resolution resolution, TickType tickType, TimeSpan period, bool shouldBeEmpty)
{
var historyProvider = new PolygonDataQueueHandler(false);
historyProvider.Initialize(new HistoryProviderInitializeParameters(null, null, null, null, null, null, null, false, null));
var now = new DateTime(2020, 5, 20, 15, 0, 0).RoundDown(resolution.ToTimeSpan());
var dataType = LeanData.GetDataType(resolution, tickType);
var requests = new[]
{
new HistoryRequest(now.Add(-period),
now,
dataType,
symbol,
resolution,
SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork),
TimeZones.NewYork,
null,
true,
false,
DataNormalizationMode.Adjusted,
tickType)
};
var history = historyProvider.GetHistory(requests, TimeZones.NewYork).ToList();
if (dataType == typeof(TradeBar))
{
foreach (var slice in history)
{
var bar = slice.Bars[symbol];
Log.Trace($"{bar.Time}: {bar.Symbol} - O={bar.Open}, H={bar.High}, L={bar.Low}, C={bar.Close}");
}
}
else if (dataType == typeof(QuoteBar))
{
foreach (var slice in history)
{
var bar = slice.QuoteBars[symbol];
Log.Trace($"{bar.Time}: {bar.Symbol} - O={bar.Open}, H={bar.High}, L={bar.Low}, C={bar.Close}");
}
}
else if (dataType == typeof(Tick))
{
foreach (var slice in history)
{
var ticks = slice.Ticks[symbol];
foreach (var tick in ticks)
{
Log.Trace($"{tick.Time}: {tick.Symbol} - B={tick.BidPrice}, A={tick.AskPrice}, P={tick.LastPrice}, Q={tick.Quantity}");
}
}
}
Log.Trace("Data points retrieved: " + historyProvider.DataPointCount);
if (shouldBeEmpty)
{
Assert.IsTrue(history.Count == 0);
}
else
{
Assert.IsTrue(history.Count > 0);
}
}
/// <summary>
/// Utility method to get historical data for a list of securities
/// </summary>
/// <param name="securities">List of securities you want historical data for</param>
/// <param name="start">Start date of the history request</param>
/// <param name="end">End date of the history request</param>
/// <param name="resolution">Resolution of the history request</param>
/// <returns>Enumerable of slices</returns>
public static IEnumerable <Slice> GetHistory(List <Security> securities, DateTime start, DateTime end, Resolution resolution)
{
var looper = new PortfolioLooper(0, new List <Order>(), resolution);
looper.Algorithm.SetStartDate(start);
looper.Algorithm.SetEndDate(end);
return(GetHistory(looper.Algorithm, securities, resolution));
}
/// <summary>
/// Creates an instance of the PortfolioLooper class
/// </summary>
/// <param name="startingCash">Equity curve</param>
/// <param name="orders">Order events</param>
/// <param name="resolution">Optional parameter to override default resolution (Hourly)</param>
private PortfolioLooper(double startingCash, List <Order> orders, Resolution resolution = _resolution)
{
// Initialize the providers that the HistoryProvider requires
var factorFileProvider = Composer.Instance.GetExportedValueByTypeName <IFactorFileProvider>("LocalDiskFactorFileProvider");
var mapFileProvider = Composer.Instance.GetExportedValueByTypeName <IMapFileProvider>("LocalDiskMapFileProvider");
var dataCacheProvider = new ZipDataCacheProvider(new DefaultDataProvider(), false);
var historyProvider = Composer.Instance.GetExportedValueByTypeName <IHistoryProvider>("SubscriptionDataReaderHistoryProvider");
historyProvider.Initialize(new HistoryProviderInitializeParameters(null, null, null, dataCacheProvider, mapFileProvider, factorFileProvider, (_) => { }, false));
Algorithm = new PortfolioLooperAlgorithm((decimal)startingCash, orders);
Algorithm.SetHistoryProvider(historyProvider);
// Dummy LEAN datafeed classes and initializations that essentially do nothing
var job = new BacktestNodePacket(1, 2, "3", null, 9m, $"");
var feed = new MockDataFeed();
// Create MHDB and Symbol properties DB instances for the DataManager
var marketHoursDatabase = MarketHoursDatabase.FromDataFolder();
var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder();
_dataManager = new DataManager(feed,
new UniverseSelection(
Algorithm,
new SecurityService(Algorithm.Portfolio.CashBook,
marketHoursDatabase,
symbolPropertiesDataBase,
Algorithm,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCacheProvider(Algorithm.Portfolio))),
Algorithm,
Algorithm.TimeKeeper,
marketHoursDatabase,
false,
RegisteredSecurityDataTypesProvider.Null);
_securityService = new SecurityService(Algorithm.Portfolio.CashBook,
marketHoursDatabase,
symbolPropertiesDataBase,
Algorithm,
RegisteredSecurityDataTypesProvider.Null,
new SecurityCacheProvider(Algorithm.Portfolio));
var transactions = new BacktestingTransactionHandler();
var results = new BacktestingResultHandler();
// Initialize security services and other properties so that we
// don't get null reference exceptions during our re-calculation
Algorithm.Securities.SetSecurityService(_securityService);
Algorithm.SubscriptionManager.SetDataManager(_dataManager);
// Initializes all the proper Securities from the orders provided by the user
Algorithm.FromOrders(orders);
// Initialize the algorithm
Algorithm.Initialize();
Algorithm.PostInitialize();
// More initialization, this time with Algorithm and other misc. classes
results.Initialize(job, new Messaging.Messaging(), new Api.Api(), transactions);
results.SetAlgorithm(Algorithm, Algorithm.Portfolio.TotalPortfolioValue);
transactions.Initialize(Algorithm, new BacktestingBrokerage(Algorithm), results);
feed.Initialize(Algorithm, job, results, null, null, null, _dataManager, null);
// Begin setting up the currency conversion feed if needed
var coreSecurities = Algorithm.Securities.Values.ToList();
if (coreSecurities.Any(x => x.Symbol.SecurityType == SecurityType.Forex || x.Symbol.SecurityType == SecurityType.Crypto))
{
BaseSetupHandler.SetupCurrencyConversions(Algorithm, _dataManager.UniverseSelection);
var conversionSecurities = Algorithm.Securities.Values.Where(s => !coreSecurities.Contains(s)).ToList();
// Skip the history request if we don't need to convert anything
if (conversionSecurities.Any())
{
// Point-in-time Slices to convert FX and Crypto currencies to the portfolio currency
_conversionSlices = GetHistory(Algorithm, conversionSecurities, resolution);
}
}
}
private void updateResolution()
{
Resolution = new Resolution(window.Width, window.Height);
}
/// <summary>
/// Gets the history for the given symbols from the <paramref name="start"/> to the <paramref name="end"/>
/// </summary>
/// <param name="symbols">Symbols to request history for</param>
/// <param name="start">Start date of history request</param>
/// <param name="end">End date of history request</param>
/// <param name="resolution">Resolution of history request</param>
/// <returns>Enumerable of slices</returns>
public static IEnumerable <Slice> GetHistory(List <Symbol> symbols, DateTime start, DateTime end, Resolution resolution)
{
// Handles the conversion of Symbol to Security for us.
var looper = new PortfolioLooper(0, new List <Order>(), resolution);
var securities = new List <Security>();
looper.Algorithm.SetStartDate(start);
looper.Algorithm.SetEndDate(end);
foreach (var symbol in symbols)
{
var configs = looper.Algorithm.SubscriptionManager.SubscriptionDataConfigService.Add(symbol, resolution, false, false);
securities.Add(looper.Algorithm.Securities.CreateSecurity(symbol, configs));
}
return(GetHistory(looper.Algorithm, securities, resolution));
}
public void SetResolution(int resolutionindex)
{
Resolution res = resolutions[resolutionindex];
Screen.SetResolution(res.width, res.height, false);
}
/// <summary>
/// Downloads a list of QuoteBars at the requested resolution
/// </summary>
/// <param name="symbol">The symbol</param>
/// <param name="startTimeUtc">The starting time (UTC)</param>
/// <param name="endTimeUtc">The ending time (UTC)</param>
/// <param name="resolution">The requested resolution</param>
/// <param name="requestedTimeZone">The requested timezone for the data</param>
/// <returns>The list of bars</returns>
public override IEnumerable <QuoteBar> DownloadQuoteBars(Symbol symbol, DateTime startTimeUtc, DateTime endTimeUtc, Resolution resolution, DateTimeZone requestedTimeZone)
{
var oandaSymbol = SymbolMapper.GetBrokerageSymbol(symbol);
var startUtc = startTimeUtc.ToStringInvariant("yyyy-MM-ddTHH:mm:ssZ");
// Oanda only has 5-second bars, we return these for Resolution.Second
var period = resolution == Resolution.Second ? TimeSpan.FromSeconds(5) : resolution.ToTimeSpan();
var response = _apiRest.GetInstrumentCandles(Authorization, oandaSymbol, null, "BA", ToGranularity(resolution).ToString(), OandaBrokerage.MaxBarsPerRequest, startUtc);
foreach (var candle in response.Candles)
{
var time = GetTickDateTimeFromString(candle.Time);
if (time > endTimeUtc)
{
break;
}
yield return(new QuoteBar(
time.ConvertFromUtc(requestedTimeZone),
symbol,
new Bar(
candle.Bid.O.ToDecimal(),
candle.Bid.H.ToDecimal(),
candle.Bid.L.ToDecimal(),
candle.Bid.C.ToDecimal()
),
0,
new Bar(
candle.Ask.O.ToDecimal(),
candle.Ask.H.ToDecimal(),
candle.Ask.L.ToDecimal(),
candle.Ask.C.ToDecimal()
),
0,
period));
}
}
/// <summary>
/// Creates a new PathInfo
/// </summary>
/// <param name="resolution">Display resolution</param>
/// <param name="colorFormat">Display color format</param>
/// <param name="targetInfos">Target configuration informations</param>
public PathInfo(Resolution resolution, ColorFormat colorFormat, PathTargetInfo[] targetInfos)
{
Resolution = resolution;
ColorFormat = colorFormat;
TargetsInfo = targetInfos;
}
/// <summary> /// Downloads a list of QuoteBars at the requested resolution /// </summary> /// <param name="symbol">The symbol</param> /// <param name="startTimeUtc">The starting time (UTC)</param> /// <param name="endTimeUtc">The ending time (UTC)</param> /// <param name="resolution">The requested resolution</param> /// <param name="requestedTimeZone">The requested timezone for the data</param> /// <returns>The list of bars</returns> public abstract IEnumerable <QuoteBar> DownloadQuoteBars(Symbol symbol, DateTime startTimeUtc, DateTime endTimeUtc, Resolution resolution, DateTimeZone requestedTimeZone);
public TestWarmupAlgorithm(Resolution resolution)
{
_resolution = resolution;
}
public static bool IsEqual(this Resolution value, Resolution comparand) => value.width == comparand.width && value.height == comparand.height;
public static string Namespace(this Resolution resolution)
{
return(resolution.MessageType.Contains("#") ? resolution.MessageType.Split('#')[0] : null);
}
public void WarmupDifferentResolutions(Resolution resolution, SecurityType securityType)
{
_algorithm = TestSetupHandler.TestAlgorithm = new TestWarmupAlgorithm(resolution);
_algorithm.SecurityType = securityType;
if (securityType == SecurityType.Forex)
{
_algorithm.StartDateToUse = new DateTime(2014, 05, 03);
_algorithm.EndDateToUse = new DateTime(2014, 05, 04);
}
else if (securityType == SecurityType.Equity)
{
_algorithm.StartDateToUse = new DateTime(2013, 10, 09);
_algorithm.EndDateToUse = new DateTime(2013, 10, 10);
}
else if (securityType == SecurityType.Crypto)
{
_algorithm.StartDateToUse = new DateTime(2018, 04, 06);
_algorithm.EndDateToUse = new DateTime(2018, 04, 07);
}
AlgorithmRunner.RunLocalBacktest(nameof(TestWarmupAlgorithm),
new Dictionary <string, string> {
{ "Total Trades", "1" }
},
null,
Language.CSharp,
AlgorithmStatus.Completed,
setupHandler: "TestSetupHandler");
int estimateExpectedDataCount;
switch (resolution)
{
case Resolution.Tick:
estimateExpectedDataCount = 2 * (securityType == SecurityType.Forex ? 19 : 4) * 60;
break;
case Resolution.Second:
estimateExpectedDataCount = 2 * (securityType == SecurityType.Forex ? 19 : 6) * 60 * 60;
break;
case Resolution.Minute:
estimateExpectedDataCount = 2 * (securityType == SecurityType.Forex ? 19 : 6) * 60;
break;
case Resolution.Hour:
estimateExpectedDataCount = 2 * (securityType == SecurityType.Forex ? 19 : 6);
break;
case Resolution.Daily:
estimateExpectedDataCount = 2;
break;
default:
throw new ArgumentOutOfRangeException(nameof(resolution), resolution, null);
}
Log.Trace($"WarmUpDataCount: {_algorithm.WarmUpDataCount}. Resolution {resolution}. SecurityType {securityType}");
Assert.GreaterOrEqual(_algorithm.WarmUpDataCount, estimateExpectedDataCount);
}
public Preferences()
{
volume = 5;
resolution = new Resolution();
quality = 3;
}
public static string MessageName(this Resolution resolution)
{
return(resolution.MessageType.Contains("#") ? resolution.MessageType.Split('#')[1] : resolution.MessageType);
}
internal override void UpdateValue(bool force)
{
if (!inited && (HasData()))
{
Activate();
return;
}
if (inited && (!HasData()))
{
Deactivate();
return;
}
if (!enabled)
{
return;
}
bool needNewLine = false;
if (text == null)
{
text = new StringBuilder(500);
}
else
{
text.Length = 0;
}
if (cpuModel)
{
text.Append("CPU: ").Append(SystemInfo.processorType).Append(" [").Append(SystemInfo.processorCount).Append(" cores]");
needNewLine = true;
}
if (gpuModel)
{
if (needNewLine)
{
text.Append(AFPSCounter.NEW_LINE);
}
text.Append("GPU: ").Append(SystemInfo.graphicsDeviceName)
.Append(", API: ").Append(SystemInfo.graphicsDeviceVersion);
bool previousExists = true;
int sm = SystemInfo.graphicsShaderLevel;
if (sm == 20)
{
text.Append(AFPSCounter.NEW_LINE).Append("GPU: SM: 2.0");
}
else if (sm == 30)
{
text.Append(AFPSCounter.NEW_LINE).Append("GPU: SM: 3.0");
}
else if (sm == 40)
{
text.Append(AFPSCounter.NEW_LINE).Append("GPU: SM: 4.0");
}
else if (sm == 41)
{
text.Append(AFPSCounter.NEW_LINE).Append("GPU: SM: 4.1");
}
else if (sm == 50)
{
text.Append(AFPSCounter.NEW_LINE).Append("GPU: SM: 5.0");
}
else
{
previousExists = false;
}
#if !UNITY_5
int fillRate = SystemInfo.graphicsPixelFillrate;
if (fillRate > 0)
{
if (previousExists)
{
text.Append(", FR: ");
}
else
{
text.Append(AFPSCounter.NEW_LINE).Append("GPU: FR: ");
}
text.Append(fillRate).Append(" MP/S");
previousExists = true;
}
#endif
int vram = SystemInfo.graphicsMemorySize;
if (vram > 0)
{
if (previousExists)
{
text.Append(", VRAM: ");
}
else
{
text.Append(AFPSCounter.NEW_LINE).Append("GPU: VRAM: ");
}
text.Append(vram).Append(" MB");
}
needNewLine = true;
}
if (ramSize)
{
if (needNewLine)
{
text.Append(AFPSCounter.NEW_LINE);
}
int ram = SystemInfo.systemMemorySize;
if (ram > 0)
{
text.Append("RAM: ").Append(ram).Append(" MB");
needNewLine = true;
}
else
{
needNewLine = false;
}
}
if (screenData)
{
if (needNewLine)
{
text.Append(AFPSCounter.NEW_LINE);
}
Resolution res = Screen.currentResolution;
text.Append("SCR: ").Append(res.width).Append("x").Append(res.height).Append("@").Append(res.refreshRate).Append("Hz [window size: ").Append(Screen.width).Append("x").Append(Screen.height);
float dpi = Screen.dpi;
if (dpi > 0)
{
text.Append(", DPI: ").Append(dpi).Append("]");
}
else
{
text.Append("]");
}
}
LastValue = text.ToString();
if (main.OperationMode == OperationMode.Normal)
{
text.Insert(0, colorCached);
text.Append("</color>");
}
else
{
text.Length = 0;
}
dirty = true;
}
public Task <Candle[]> GetCandles(string symbol, Resolution resolution, DateTime from)
{
return(GetCandles(symbol, resolution, from, DateTime.UtcNow));
}
