internal DynamicBoundConfiguration(
char valueSeparator,
char escapedValueStartAndStop,
char escapeValueEscapeChar,
RowEndings rowEndings,
ReadHeaders readHeader,
WriteHeaders writeHeaders,
WriteTrailingNewLines writeTrailingNewLine,
MemoryPool <char> memoryPool,
char?commentChar,
int?writeBufferSizeHint,
int readBufferSizeHint,
IDynamicTypeConverter dynamicTypeConverter,
DynamicRowDisposal dynamicRowDisposal
) :
base(
valueSeparator,
escapedValueStartAndStop,
escapeValueEscapeChar,
rowEndings,
readHeader,
writeHeaders,
writeTrailingNewLine,
memoryPool,
commentChar,
writeBufferSizeHint,
readBufferSizeHint,
dynamicTypeConverter,
dynamicRowDisposal
)
{
}
internal ConcreteBoundConfiguration(
InstanceBuilderDelegate <T> newCons,
Column[] deserializeColumns,
Column[] serializeColumns,
bool[] serializeColumnsNeedEscape,
char valueSeparator,
char escapedValueStartAndStop,
char escapeValueEscapeChar,
RowEndings rowEndings,
ReadHeaders readHeader,
WriteHeaders writeHeaders,
WriteTrailingNewLines writeTrailingNewLine,
MemoryPool <char> memoryPool,
char?commentChar,
int?writeBufferSizeHint,
int readBufferSizeHint) : base(
newCons,
deserializeColumns,
serializeColumns,
serializeColumnsNeedEscape,
valueSeparator,
escapedValueStartAndStop,
escapeValueEscapeChar,
rowEndings,
readHeader,
writeHeaders,
writeTrailingNewLine,
memoryPool,
commentChar,
writeBufferSizeHint,
readBufferSizeHint
)
{
}
internal ReaderStateMachine(
MemoryPool <char> memoryPool,
char escapeStartChar,
char valueSeparatorChar,
char escapeChar,
RowEndings rowEndings,
ReadHeaders hasHeaders,
char?commentChar
)
{
RowEndings = rowEndings;
HasHeaders = hasHeaders;
switch (HasHeaders)
{
case ReadHeaders.Always:
CurrentState = State.Header_Start;
break;
case ReadHeaders.Never:
CurrentState = State.Record_Start;
break;
default:
Throw.InvalidOperationException($"Unexpected {nameof(ReadHeaders)}: {HasHeaders}");
break;
}
TransitionMatrixHandle = GetTransitionMatrix(RowEndings, escapeStartChar == escapeChar).Pin();
TransitionMatrix = (TransitionRule *)TransitionMatrixHandle.Pointer;
SuppressCharLookupDispose = false;
(MinimumCharacter, CharLookupOffset, CharLookupOwner, CharLookupPin, CharLookup) =
MakeCharacterLookup(memoryPool, escapeStartChar, valueSeparatorChar, escapeChar, commentChar);
}
internal ReaderStateMachine(
CharacterLookup preAllocLookup,
char escapeStartChar,
char escapeChar,
RowEndings rowEndings,
ReadHeaders hasHeaders
)
{
RowEndings = rowEndings;
HasHeaders = hasHeaders;
switch (HasHeaders)
{
case ReadHeaders.Always:
CurrentState = State.Header_Start;
break;
case ReadHeaders.Never:
CurrentState = State.Record_Start;
break;
default:
Throw.InvalidOperationException($"Unexpected {nameof(ReadHeaders)}: {HasHeaders}");
break;
}
TransitionMatrixHandle = GetTransitionMatrix(RowEndings, escapeStartChar == escapeChar).Pin();
TransitionMatrix = (TransitionRule *)TransitionMatrixHandle.Pointer;
SuppressCharLookupDispose = true;
(MinimumCharacter, CharLookupOffset, _, _, CharLookup) = preAllocLookup;
}
/// <summary>
/// For working with concrete types.
/// </summary>
protected BoundConfigurationBase(
InstanceBuilderDelegate <T> newCons,
Column[] deserializeColumns,
Column[] serializeColumns,
bool[] serializeColumnsNeedEscape,
char valueSeparator,
char escapedValueStartAndStop,
char escapeValueEscapeChar,
RowEndings rowEndings,
ReadHeaders readHeader,
WriteHeaders writeHeaders,
WriteTrailingNewLines writeTrailingNewLine,
MemoryPool <char> memoryPool,
char?commentChar,
int?writeBufferSizeHint,
int readBufferSizeHint
)
{
NewCons = newCons;
DeserializeColumns = deserializeColumns;
SerializeColumns = serializeColumns;
SerializeColumnsNeedEscape = serializeColumnsNeedEscape;
ValueSeparator = valueSeparator;
ValueSeparatorMemory = ValueSeparator.ToString().AsMemory();
EscapedValueStartAndStop = escapedValueStartAndStop;
EscapeValueEscapeChar = escapeValueEscapeChar;
RowEnding = rowEndings;
WriteBufferSizeHint = writeBufferSizeHint;
ReadBufferSizeHint = readBufferSizeHint;
switch (RowEnding)
{
case RowEndings.CarriageReturn:
RowEndingMemory = CarriageReturn;
break;
case RowEndings.CarriageReturnLineFeed:
RowEndingMemory = CarriageReturnLineFeed;
break;
case RowEndings.LineFeed:
RowEndingMemory = LineFeed;
break;
default:
// for cases like detecting headers, actually trying to write is NO GOOD...
// but construction is fine
RowEndingMemory = default;
break;
}
ReadHeader = readHeader;
WriteHeader = writeHeaders;
WriteTrailingNewLine = writeTrailingNewLine;
MemoryPool = memoryPool;
CommentChar = commentChar;
DynamicTypeConverter = null;
}
/// <summary>
/// Set whether or not to read headers.
/// </summary>
public OptionsBuilder WithReadHeader(ReadHeaders r)
{
if (!Enum.IsDefined(Types.ReadHeadersType, r))
{
Throw.ArgumentException($"Unexpected {nameof(ReadHeaders)} value: {r}", nameof(r));
}
return(WithReadHeaderInternal(r));
}
private static async Task <string> GetReadOperationRequestAsync(string imageUrl)
{
ReadHeaders result = await RunTaskWithAutoRetryOnQuotaLimitExceededError(() => client.ReadAsync(imageUrl));
string operationLocation = result.OperationLocation;
// Retrieve the URI where the extracted text will be stored from the Operation-Location header.
// We only need the ID and not the full URL
return(operationLocation.Substring(operationLocation.Length - NumberOfCharsInOperationId));
}
public void ReadTest()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "BatchReadFileTest");
string imageUrl = GetTestImageUrl("signage.jpg");
using (IComputerVisionClient client = GetComputerVisionClient(HttpMockServer.CreateInstance()))
{
ReadHeaders headers = client.ReadAsync(imageUrl).Result;
Assert.NotNull(headers.OperationLocation);
ReadOperationResult readOperationResult = GetRecognitionResultWithPolling(client, headers.OperationLocation);
Assert.NotNull(readOperationResult);
Assert.Equal(OperationStatusCodes.Succeeded, readOperationResult.Status);
Assert.NotNull(readOperationResult.AnalyzeResult);
Assert.Equal(1, readOperationResult.AnalyzeResult.ReadResults.Count);
var recognitionResult = readOperationResult.AnalyzeResult.ReadResults[0];
Assert.Equal(1, recognitionResult.Page);
Assert.Equal(250, recognitionResult.Width);
Assert.Equal(258, recognitionResult.Height);
Assert.Equal(TextRecognitionResultDimensionUnit.Pixel, recognitionResult.Unit);
Assert.Equal(
new string[] { "520", "WEST", "Seattle" }.OrderBy(t => t),
recognitionResult.Lines.Select(line => line.Text).OrderBy(t => t));
Assert.Equal(
new string[] { "520", "WEST", "Seattle" }.OrderBy(t => t),
recognitionResult.Lines.SelectMany(line => line.Words).Select(word => word.Text).OrderBy(t => t));
Assert.Equal(3, recognitionResult.Lines.Count);
}
}
}
static async Task Main(string[] args)
{
const string SUBSCRIPTION_KEY = "PONER AQUI LA CLAVE";
const string ENDPOINT = "PONER AQUI LA URL DEL ENDPOINT";
const string IMAGE_BASE_URL = "https://moderatorsampleimages.blob.core.windows.net/samples";
ComputerVisionClient client = new ComputerVisionClient(new ApiKeyServiceClientCredentials(SUBSCRIPTION_KEY))
{
Endpoint = ENDPOINT
};
/////////////////////////
//Análisis de imagen (ComputerVision-Analyze Image)
/////////////////////////
Console.WriteLine("---Análisis de imagen---");
//Definimos la lista de características y detalles que queremos obtener de la imagen
List <VisualFeatureTypes?> caracteristicas = new List <VisualFeatureTypes?>()
{
VisualFeatureTypes.Categories, VisualFeatureTypes.Description,
VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
VisualFeatureTypes.Objects
};
List <Details?> detalles = new List <Details?>()
{
Details.Celebrities
};
//Invocamos el método de la API para el análisis de la imagen
ImageAnalysis resultado = await client.AnalyzeImageAsync(
url : $"{IMAGE_BASE_URL}/sample1.jpg",
visualFeatures : caracteristicas,
details : detalles,
language : "es"
);
//Procesamos el resultado
//Descripción
Console.WriteLine($"Descripción:{resultado.Description.Captions[0].Text}");
//Categorías
Console.WriteLine("Categorías:");
foreach (Category categoria in resultado.Categories)
{
Console.WriteLine($"\t{categoria.Name} ({categoria.Score})");
}
;
//Etiquetas
Console.WriteLine("Etiquetas:");
foreach (ImageTag etiqueta in resultado.Tags)
{
Console.WriteLine($"\t{etiqueta.Name} ({etiqueta.Confidence})");
}
;
//Contenido para adultos
Console.WriteLine($"¿Contenido para adultos? {resultado.Adult.IsAdultContent}");
Console.WriteLine($"¿Contenido subido de tono? {resultado.Adult.IsRacyContent}");
Console.WriteLine($"¿Contenido sangriento? {resultado.Adult.IsGoryContent}");
//Objetos encontrados
Console.WriteLine("Objetos:");
foreach (DetectedObject objeto in resultado.Objects)
{
Console.WriteLine($"\t{objeto.ObjectProperty} ({objeto.Rectangle.W},{objeto.Rectangle.H},{objeto.Rectangle.X},{objeto.Rectangle.Y})");
}
;
//Famosos
Console.WriteLine("Famosos:");
foreach (Category categoria in resultado.Categories)
{
if (categoria.Detail?.Celebrities != null)
{
foreach (CelebritiesModel famoso in categoria.Detail.Celebrities)
{
Console.WriteLine($"\t{famoso.Name}");
}
}
}
/////////////////////////
//Obtención de miniatura (ComputerVision-Get Thumbnail)
/////////////////////////
Console.WriteLine("---Obtención de miniatura---");
//Invocamos el método de la API para obtener la miniatura
Stream miniatura = await client.GenerateThumbnailAsync(100, 100, $"{IMAGE_BASE_URL}/sample6.png", true);
//Almacenamos el stream del resultado en un fichero local
using (Stream file = File.Create("./miniatura.jpg")) { miniatura.CopyTo(file); }
Console.WriteLine($"Generado el fichero miniatura.jpg");
/////////////////////////
//OCR (ComputerVision-Read)
/////////////////////////
Console.WriteLine("---OCR---");
//Invocamos el método de la API para solicitar la operación de lectura
ReadHeaders operacionOCR = await client.ReadAsync($"{IMAGE_BASE_URL}/sample2.jpg", language : "es");
//Obtenemos el identificador de la operaciónd e lectura
string localizador = operacionOCR.OperationLocation;
string idOperacion = localizador.Substring(localizador.Length - 36);
//Esperamos a que la operación de lectura acabe
ReadOperationResult resultadoOCR;
while (true)
{
await Task.Delay(1000);
resultadoOCR = await client.GetReadResultAsync(Guid.Parse(idOperacion));
if (resultadoOCR.Status == OperationStatusCodes.Succeeded)
{
break;
}
}
//Procesamos el resultado
Console.WriteLine("Texto encontrado:");
foreach (ReadResult pagina in resultadoOCR.AnalyzeResult.ReadResults)
{
foreach (Line linea in pagina.Lines)
{
Console.WriteLine($"\t{linea.Text}");
}
}
}
// sometimes we want to skip validation in tests
internal OptionsBuilder WithReadHeaderInternal(ReadHeaders r)
{
ReadHeader = r;
return(this);
}
