/// <summary> /// Construct a request for the online service to annotate or classify a document downloaded directly from a remote URL /// </summary> /// <param name="documentUrl">the URL from which the document should be downloaded</param> /// <param name="type">the MIME type that the service should use to parse the document</param> /// <param name="imageTagging">The boolean flag to allow/deny image tagging of the document</param> /// <param name="imageCategorization">The boolean flag to allow/deny image categorization of the document</param> public ServiceRequest(Uri documentUrl, SupportedMimeType type, bool imageTagging, bool imageCategorization) { this.DocumentUrl = documentUrl.ToString(); this.DocumentType = type.ToStringValue(); this.ImageTagging = imageTagging; this.ImageCategorization = imageCategorization; }
/// <summary> /// Construct a request for the online service to annotate or classify a document provided as part of the request. /// </summary> /// <param name="document">the content to process.</param> /// <param name="type">the MIME type that the service should use to parse the document.</param> public ServiceRequest(String document, SupportedMimeType type) { this.Document = document; this.DocumentType = type.ToStringValue(); this.ImageTagging = false; this.ImageCategorization = false; }
/// <summary> /// Annotates a single document publicly available under a given URL. /// Returns an object which allows for convenient access to the /// annotations in the annotated document /// </summary> /// <param name="documentUrl">the publicly accessible URL from where the document will be downloaded</param> /// <param name="documentMimeType">the MIME type of the document which will be annotated</param> /// <returns>an {@link AnnotatedDocument} which allows for convenient programmatic access to the annotated document</returns> public AnnotatedDocument annotateDocumentFromUrl(Uri documentUrl, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentUrl, documentMimeType, null); return(processRequest(rq, true)); }
/// <summary> /// Annotates a single document with the specified MIME type. Returns /// an object which allows for convenient access to the annotations in /// the annotated document. /// </summary> /// <param name="documentText">the document content to annotate</param> /// <param name="documentMimeType"> the MIME type of the document which will beannotated</param> /// <returns>an {@link AnnotatedDocument} containing the original content as well as the annotations produced</returns> public AnnotatedDocument annotateDocument(String documentText, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentText, documentMimeType, null); return(processRequest(rq, true)); }
/// <summary> /// Construct a request for the online service to annotate a document /// it downloads directly from a remote URL. /// </summary> /// <param name="documentUrl">the URL from which the document should be /// downloaded. This must be accessible to the service so it /// must not require authentication credentials etc. (but it /// may be, for example, a pre-signed Amazon S3 URL).</param> /// <param name="type">the MIME type that the service should use to parse the /// document.</param> /// <param name="annotationSelectors">annotations to return. Leave as /// <code>null</code> to use the default selectors recommended /// by the pipeline provider.</param> public ServiceRequest(Uri documentUrl, SupportedMimeType type, List<AnnotationSelector> annotationSelectors) { this.documentUrl = documentUrl.ToString(); this.documentType = type.ToStringValue(); if (annotationSelectors != null) { this.annotationSelectors = new List<string>(); foreach (AnnotationSelector aSel in annotationSelectors) { this.annotationSelectors.Add(aSel.ToString()); } } }
/// <summary> /// Annotates a document publicly available under a given URL and tags and/or categorizes any images inside. /// </summary> /// <param name="documentUrl">the publicly accessible URL from where the document will be downloaded</param> /// <param name="documentMimeType">the MIME type of the document which will be annotated</param> /// <param name="serializationFormat">the serialization format of the output</param> /// <returns>Аn {@link InputStream} from where the serialized output can be read</returns> public Stream annotateDocumentAsStream(Uri documentUrl, SupportedMimeType documentMimeType, ResponseFormat serializationFormat, bool imageTagging, bool imageCategorization) { ServiceRequest rq = new ServiceRequest(documentUrl, documentMimeType, imageTagging, imageCategorization); try { return(client.requestForStream("", "POST", rq, constructHeaders(serializationFormat))); } catch (HttpClientException e) { String msg = handleErrors(e); throw new S4ServiceClientException(msg == null ? e.Message : msg, e); } }
/// <summary> /// Annotates a single document and returns an {@link InputStream} from /// which the contents of the serialized annotated document can be read /// </summary> /// <param name="documentText">the contents of the document which will be annotated</param> /// <param name="documentMimeType">the MIME type of the file which will be annotated</param> /// <param name="serializationFormat">the format which will be used for serialization of the annotated document</param> /// <returns>an {@link InputStream} from which the serialization of the annotated document can be read</returns> public Stream annotateDocumentAsStream(String documentText, SupportedMimeType documentMimeType, ResponseFormat serializationFormat) { ServiceRequest rq = new ServiceRequest(documentText, documentMimeType); try { return(client.requestForStream("", "POST", rq, constructHeaders(serializationFormat))); } catch (HttpClientException e) { String msg = handleErrors(e); throw new S4ServiceClientException(msg == null ? e.Message : msg.ToString()); } }
/// <summary> /// Construct a request for the online service to annotate a document /// it downloads directly from a remote URL. /// </summary> /// <param name="documentUrl">the URL from which the document should be /// downloaded. This must be accessible to the service so it /// must not require authentication credentials etc. (but it /// may be, for example, a pre-signed Amazon S3 URL).</param> /// <param name="type">the MIME type that the service should use to parse the /// document.</param> /// <param name="annotationSelectors">annotations to return. Leave as /// <code>null</code> to use the default selectors recommended /// by the pipeline provider.</param> public ServiceRequest(Uri documentUrl, SupportedMimeType type, List <AnnotationSelector> annotationSelectors) { this.documentUrl = documentUrl.ToString(); this.documentType = type.ToStringValue(); if (annotationSelectors != null) { this.annotationSelectors = new List <string>(); foreach (AnnotationSelector aSel in annotationSelectors) { this.annotationSelectors.Add(aSel.ToString()); } } }
/// <summary> /// Classifies a single document publicly available under a given URL. /// Returns the classification information for the document serialized into the specified format /// </summary> /// <param name="documentUrl">the publicly accessible URL from where the document will be downloaded</param> /// <param name="documentMimeType">the MIME type of the document which will be classified</param> /// <returns>Аn {@link InputStream} from where the serialized output can be read</returns> public Stream classifyDocumentAsStream(Uri documentUrl, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentUrl, documentMimeType); try { return(client.requestForStream("", "POST", rq, constructHeaders(ResponseFormat.JSON))); } catch (HttpClientException e) { String msg = handleErrors(e); throw new S4ServiceClientException(msg == null ? e.Message : msg, e); } }
/// <summary> /// Classifies the contents of a single file returning an {@link InputStream} /// from which the classification information can be read /// </summary> /// <param name="documentContent">the file which will be classified</param> /// <param name="documentEncoding">the encoding of the file which will be classified</param> /// <param name="documentMimeType">the MIME type of the file which will be classified</param> public Stream classifyDocumentAsStream(FileStream documentContent, String documentEncoding, SupportedMimeType documentMimeType) { String documentPath = Path.GetFullPath(documentContent.Name); if (!documentContent.CanRead) { throw new IOException("File " + documentPath + " is not readable."); } Byte[] buff; buff = File.ReadAllBytes(documentPath); Encoding encode = System.Text.Encoding.GetEncoding(documentEncoding); String content = new UTF8Encoding().GetString(buff); return(classifyDocumentAsStream(content, documentMimeType)); }
/// <summary> /// Annotates the contents of a single file returning an {@link InputStream} from which the annotated content can be read /// </summary> /// <param name="documentContent">the file which will be annotated</param> /// <param name="documentEncoding">the encoding of the file which will be annotated</param> /// <param name="documentMimeType">the MIME type of the file which will be annotated</param> /// <param name="serializationFormat">the serialization format used for the annotated content</param> public Stream annotateFileContentsAsStream(FileStream documentContent, String documentEncoding, SupportedMimeType documentMimeType, ResponseFormat serializationFormat) { String documentPath = Path.GetFullPath(documentContent.Name); if (!documentContent.CanRead) { throw new IOException("File " + documentPath + " is not readable."); } Byte[] buff; buff = File.ReadAllBytes(documentPath); Encoding encode = System.Text.Encoding.GetEncoding(documentEncoding); String content = new UTF8Encoding().GetString(buff); return(annotateDocumentAsStream(content, documentMimeType, serializationFormat)); }
private static void CompressImage(string filePath, Bitmap img, string savePath, int quality, Size size, SupportedMimeType type, bool isOnlyForDisplay = true) { ImageCodecInfo imageCodecInfo; if (type == SupportedMimeType.JPEG) { imageCodecInfo = Helper.GetEncoderInfo("image/jpeg"); } else if (type == SupportedMimeType.PNG) { imageCodecInfo = Helper.GetEncoderInfo("image/png"); } else { imageCodecInfo = Helper.GetEncoderInfoFromOriginalFile(filePath); } EncoderParameters encoderParameters; if (img.Size.Height < size.Height || img.Size.Width < size.Width) { size = img.Size; } Bitmap imgCompressed = new Bitmap(img, size); foreach (var id in img.PropertyIdList) { imgCompressed.SetPropertyItem(img.GetPropertyItem(id)); } SetImageComments(imgCompressed); img.Dispose(); encoderParameters = new EncoderParameters(1); encoderParameters.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality); imgCompressed.Save(Helper.FolderSaveFile(filePath, savePath), imageCodecInfo, encoderParameters); imgCompressed.Dispose(); }
/// <summary> /// Classifies a single document and returns an {@link InputStream} from /// which the contents of the serialized classified document can be read /// </summary> /// <param name="documentText">the contents of the document which will be classified</param> /// <param name="documentMimeType">the MIME type of the file which will be classified</param> /// <returns>an {@link InputStream} from which the serialization of the classified document can be read</returns> public Stream classifyDocumentAsStream(String documentText, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentText, documentMimeType); WebHeaderCollection headers = new WebHeaderCollection(); headers.Add("Accept", ResponseFormat.JSON.ToStringValue()); try { return(client.requestForStream("", "POST", rq, headers)); } catch (HttpClientException e) { JsonObject response = e.getResponse(); if (response == null) { throw new S4ServiceClientException(e.Message); } String msg = response.ToString(); throw new S4ServiceClientException(msg == null ? e.Message : msg.ToString()); } }
/// <summary> /// Annotates the contents of a single file with the specified MIME /// type. Returns an object which allows for convenient access to the /// annotations in the annotated document. /// </summary> /// <param name="documentContent">the file whose contents will be annotated</param> /// <param name="documentEncoding">the encoding of the document file</param> /// <param name="documentMimeType">the MIME type of the document to annotated</param> /// <returns>an {@link AnnotatedDocument} containing the original content as well as the annotations produced</returns> public AnnotatedDocument annotateFileContents(FileStream documentContent, String documentEncoding, SupportedMimeType documentMimeType) { String documentPath = Path.GetFullPath(documentContent.Name); if (!File.Exists(documentPath)) { throw new IOException("File " + documentPath.ToString() + " is not readable."); } MemoryStream stream = new MemoryStream(); using (BinaryWriter writer = new BinaryWriter(stream)) { writer.Write(File.ReadAllBytes(documentPath)); } byte[] bytes = stream.ToArray(); String content = Encoding.UTF8.GetString(bytes); return(annotateDocument(content, documentMimeType)); }
/// <summary> /// Classifies a single document publicly available under a given URL. /// Returns the classification information for the document serialized into the specified format /// </summary> /// <param name="documentUrl">the publicly accessible URL from where the document will be downloaded</param> /// <param name="documentMimeType">the MIME type of the document which will be classified</param> /// <returns>an {@link InputStream} from where the serialized output can be read</returns> public Stream classifyDocumentFromUrlAsStream(Uri documentUrl, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentUrl, documentMimeType); try { WebHeaderCollection collection = new WebHeaderCollection(); collection.Set(HttpRequestHeader.Accept, ResponseFormat.JSON.ToStringValue()); return(client.requestForStream("", "POST", rq, collection)); } catch (HttpClientException e) { JsonObject response = e.getResponse(); if (response == null) { throw new S4ServiceClientException(e.Message, e); } String msg = response.ToString(); throw new S4ServiceClientException(msg == null ? e.Message : msg, e); } }
/// <summary> /// Construct a request for the online service to annotate or classify a document provided as part of the request. /// </summary> /// <param name="document">the content to process.</param> /// <param name="type">the MIME type that the service should use to parse the document.</param> public ServiceRequest(String document, SupportedMimeType type) { this.Document = document; this.DocumentType = type.ToStringValue(); }
/// <summary> /// Construct a request for the online service to annotate or classify a document downloaded directly from a remote URL /// </summary> /// <param name="documentUrl">the URL from which the document should be /// downloaded. This must be accessible to the service so it /// must not require authentication credentials etc. (but it /// may be, for example, a pre-signed Amazon S3 URL).</param> /// <param name="type">the MIME type that the service should use to parse the /// document.</param> public ServiceRequest(Uri documentUrl, SupportedMimeType type) { this.documentUrl = documentUrl.ToString(); this.documentType = type.ToStringValue(); }
/// <summary> /// Annotates a document publicly available under a given URL and tags and/or categorizes any images inside. /// </summary> /// <param name="documentUrl">the publicly accessible URL from where the document will be downloaded</param> /// <param name="documentMimeType">the MIME type of the document which will be annotated</param> /// <returns>An {@link AnnotatedDocument} object with the processed image tags and categories</returns> public AnnotatedDocument annotateDocument(Uri documentUrl, SupportedMimeType documentMimeType, bool imageTagging, bool imageCategorization) { ServiceRequest rq = new ServiceRequest(documentUrl, documentMimeType, imageTagging, imageCategorization); return(processRequest(rq)); }
/// <summary> /// Annotates a single document publicly available under a given URL. /// Returns an object which allows for convenient access to the annotations in the annotated document /// </summary> /// <param name="documentUrl">the publicly accessible URL from where the document will be downloaded</param> /// <param name="documentMimeType">the MIME type of the document which will be annotated</param> /// <returns>an {@link AnnotatedDocument} which allows for convenient programmatic access to the annotated document</returns> public AnnotatedDocument annotateDocument(Uri documentUrl, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentUrl, documentMimeType); return(processRequest(rq)); }
public static void main(String[] args) { if (args == null || args.Length == 0) { printUsageAndTerminate(null); } Parameters parameters = new Parameters(args); String serviceID = parameters.getValue("service"); if (serviceID == null) { printUsageAndTerminate("No service name provided"); } ServiceDescriptor service = null; try { service = ServiceCatalog.getItem(serviceID); } catch (NotSupportedException nse) { printUsageAndTerminate("Unsupported service '" + serviceID + '\''); Console.WriteLine(nse.Message); } SupportedMimeType mimetype = SupportedMimeType.PLAINTEXT; if (parameters.getValue("dtype") != null) { try { mimetype = NumToEnum <SupportedMimeType>(parameters.getValue("dtype").ToString()); } catch (ArgumentException ae) { printUsageAndTerminate("Unsupported document type (dtype) : " + parameters.getValue("dtype")); Console.WriteLine(ae.Message); } } String inFile = parameters.getValue("file"); String url = parameters.getValue("url"); String outFile = parameters.getValue("out", "result.txt"); if (inFile != null) { if (false == new FileStream(inFile, FileMode.OpenOrCreate).CanRead) { printUsageAndTerminate("Input file is not found : " + inFile); } } else { if (url == null) { printUsageAndTerminate("Neither input file, nor remote URL provided"); } } Dictionary <String, String> creds = readCredentials(parameters); if (false == creds.ContainsKey("apikey") || false == creds.ContainsKey("secret")) { printUsageAndTerminate("No credentials details found"); } S4ServiceClient client = new S4ServiceClient(service, creds["apikey"], creds["secret"]); try { Stream resultData = (inFile != null) ? client.annotateFileContentsAsStream(new FileStream(inFile, FileMode.OpenOrCreate), CharSet.Unicode.ToString(), mimetype, ResponseFormat.JSON) : client.annotateDocumentFromUrlAsStream(new Uri(url), mimetype, ResponseFormat.JSON); FileStream outStream = new FileStream(outFile, FileMode.Create); resultData.CopyTo(outStream); outStream.Close(); resultData.Close(); } catch (IOException ioe) { Console.WriteLine(ioe.Message); Environment.Exit(1); } }
/// <summary> /// Classifies a single document with the specified MIME type. Returns an object /// which allows for convenient access to the classification information for the document. /// </summary> /// <param name="documentText">the document content to classify</param> /// <param name="documentMimeType"> the MIME type of the document which will be classified</param> /// <returns>A {@link ClassifiedDocument} containing the original content as well as the classifications produced</returns> public ClassifiedDocument classifyDocument(String documentText, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentText, documentMimeType); return(classifyRequest(rq)); }
/// <summary> /// Classifies a single document publicly available under a given URL. /// Returns an object which allows for convenient access to the classification information for the document /// </summary> /// <param name="documentUrl">the publicly accessible URL from where the document will be downloaded</param> /// <param name="documentMimeType">the MIME type of the document which will be classified</param> /// <returns>A {@link ClassifiedDocument} which allows for convenient programmatic access to the classified document</returns> public ClassifiedDocument classifyDocument(Uri documentUrl, SupportedMimeType documentMimeType) { ServiceRequest rq = new ServiceRequest(documentUrl, documentMimeType); return(classifyRequest(rq)); }
public static void CompressImage(string filePath, string savePath, int quality, int size, SupportedMimeType type) { Bitmap img = new Bitmap(filePath); CompressImage( filePath, img, savePath, quality, new Size((int)(img.Width * size / 100), (int)(img.Height * size / 100)), type ); img.Dispose(); }