dataesr/scientific-paragraphs-categorization huggingface dataset:
Some synchrotrons have even developed their own tools for volume processing, such as Pore3D  [9]  at the Elettra facility. Alternatively, the use of a programming language gives finer control, better reproducibility, and more complex analysis possibilities, provided classical processing algorithms can be called from libraries-thereby limiting the complexity of the programming task and the risk of bugs. Matlab (TM) and its image processing toolbox are popular in the academic community of computer vision and image processing. The Python language is widely used in the scientific world and in synchrotron facilities. As a general-purpose language, Python is used in synchrotrons to control device servers  [8, 15, 51] , to access raw data of X-ray detectors  [27] , to reconstruct tomography volumes from radiographs  [23, 32] , and in data processing packages for macromolecular crystallography  [3] , azimuthal integration of diffraction data  [4] , or fluorescence analysis  [50, 52].
scikit-image  [54]  is a general-purpose image processing library for the Python language, and a component of the ecosystem of Python scientific modules commonly known as Scientific Python  [34]. Like the rest of the ecosystem, scikit-image is released under a permissive open-source license and is available free of charge. Most of scikit-image is compatible with both 2D and 3D images, so that it can be used for a large number of imaging modalities, such as microscopy, radiography, or tomography. In this article, we explain how scikit-image can be used for processing data acquired in X-ray imaging experiments, with a focus on microtomography 3D images. This article does not intend to be a pedagogical tutorial on scikit-image for X-ray imaging, but rather to explain the rationale behind the package, and provide various examples of its capabilities.
Overview and first steps In this section, we provide a short overview of the typical use patterns of scikit-image, illustrated by short snippets of code. Since Python is a programming language, the user interacts with data objects and images through code, which is either entered and executed in an interactive interpreter, or written in text files (so-called scripts) that are executed. Images are manipulated as numerical arrays, each with a single, uniform data type. This common format guarantees interoperability with other libraries and straightforward access to and interpretation of computer memory. The N-dimensional (2D, 3D,. ) numerical array object is provided by the NumPy module  [53]. In image processing in Python, one of the first tasks then is to generate NumPy arrays, which is often achieved by reading data from files.
We read one 2-dimensional image from a file and display it as follows: skimage is the name under which scikit-image is imported in Python code. Note that functions (such as imread that reads an image file, or imshow that displays an image) are found in thematic submodules of skimage, such as io for Input/Output. A stack of 2D images, such as tomography slices generated by a reconstruction algorithm, can be opened as an image collection or a 3D array: Raw data formats can be opened using the NumPy functions fromfile (to load the array into memory) or memmap (to keep the array on disk). The following code creates an array from a raw image file of unsigned 16-bit integers with a header of 1024 bytes: For every raw data specification, it is thus very easy to write a reader using np. memmap (see for example https://github.
The Python ecosystem The benefits of scikit-image for image processing come not only from the features of the package alone, but also from the rich environment surrounding scientific Python  [34, 38]. Figure  1  illustrates how several components of this ecosystem combine into a sophisticated image processing workflow. NumPy arrays are the cornerstone of the Scientific Python ecosystem, and of scikit-image operations in particular. NumPy "one-liners" include cropping or downsampling an image, or retrieving pixels corresponding to a given label in a segmentation. To illustrate the compactness of NumPy code, consider modifying pixel values below a threshold. This operation can be written as exploiting the ability to index arrays with boolean arrays, also called masking. NumPy uses memory sparingly and avoids making new copies of arrays whenever possible, an important requirement when dealing with the gigabyte-sized images of tomography.
For example, cropping a subvolume as follows does not create a copy of the original array but instead refers to the correct memory offsets in the original. Interpreter and development environment While several interpreters are available to execute Python instructions and scripts interactively, the most popular in the scientific world is IPython  [37, 44]. IPython is an advanced interpreter, which integrates syntax highlighting, text auto-completion, a debugger, introspection and profiling methods, and online help. Several integrated development environments (IDEs) come bundled with IPython, together with other components such as a text editor. Notable examples include Spyder (Fig. 2 ), PyCharm, and Visual Studio Code. The Jupyter notebook  [26]  is a web application that grew out of the IPython project.
Jupyter notebooks provide an interactive development environment within a web browser, where live code can be enriched by explanatory text, equations, and visualizations (Fig. 3 ). Jupyter notebooks render directly as webpages on GitHub, making them a straightforward tool to publish online a script and its output. As of July 2016, more than 500,000 Jupyter notebooks were posted on GitHub, demonstrating their wide adoption by the community as workflow-sharing tools (http://archive. ipython. org/media/SciPy2016Ju-pyterLab. pdf ). Visualization libraries Visualizing images is an important component of the image processing workflow, used to inspect the final result and to adjust the parameters of intermediate processing operations. matplotlib  [24]  is the most popular 2D plotting library of the Python ecosystem.
It can be used to visualize 2D data such as color or grayscale images, and 1D data such as contour lines, outlines of segmented regions, histograms of gray levels. Although matplotlib has simple 3D plotting capabilities, we recommend using the mayavi module  [42]  for applications requiring advanced 3D visualization, such as tomography. mayavi is based on the VTK toolkit. It exposes a simple API for visualizing data passed as numpy arrays. For example, visualizing the surface of binary data can be written as (see Fig. 4  for the resulting visualization). For more advanced visualizations, a large majority of VTK capabilities can be accessed through mayavi's pipeline API. mayavi offers a good trade-off between simplicity of use for common operations, and accessibility to more sophisticated capabilities such as responsive visualizations.
Advanced toolkits for signal processing and data science scikit-image is only one Python module that can be used for data processing, among many others. A very popular module is scikit-learn  [36] , a Python module for machine learning using NumPy arrays. Local features of an image (such as local statistics of gray levels, or geometric points of interest) or features of segmented objects (e. g. , geometrical and intensity characteristics of segmented particles) can be extracted with functions from skimage. feature (see Fig. 1 ). It is then possible to use a classification algorithm from scikit-learn to label pixels (a segmentation task) or to classify whole images or objects that have already been segmented. The near-universal use of NumPy arrays ensures the interoperability between these packages, so that just a few lines of code are sufficient to create these sophisticated workflows.
regionprops (see Fig. 5d ). Local characteristics of a region can be retrieved as well: Fig. 5d  shows how the local diameter of open porosity is measured by combining a skeletonization of the porosity channels, and the distance transforms to the other phase measured on the skeleton. Performance Given the large size of tomography datasets, the execution speed of image processing operations is of critical concern. scikit-image relies mostly on calls to NumPy operations, of which most are performed in optimized compiled code (C or Fortran). Performancecritical parts of scikit-image that cannot call efficient NumPy code are implemented in Cython. Cython  [5]  is an extension of the Python language that supports Fig. 2  The Spyder IDE integrates a text editor (with syntax highlighting), the IPython interpreter, as well as a panel for code introspection (online help, variable explorer,.
) explicit type declarations, and is compiled directly to C. Therefore, the performance of scikit-image can be close to the one of the libraries written in a compiled language such as C++ or Java. For example, computing the watershed segmentation of a 2000 × 2000 array of floats into 1000 regions took about 1 s using 1 CPU of an off-the-shelf laptop, and 10 s for a 256 × 256 × 256 image segmented into 2000 regions. Similar timescales were obtained with mahotas, a Python package implemented exclusively in C++  [14]  (with a slight advantage for mahotas). However, basic scikit-image code runs on a single core. Computing workstations and servers used for X-ray imaging typically have several tens of cores. Parallelization of the computing workflow can be achieved in multiple ways. The most trivial parallelization scheme consists of applying the same workflow to different images, on different cores.
However, finer-grained parallelization is preferable when prototyping the processing workflow. An easy solution consists in dividing an image into smaller images (with or without overlap, depending on the operation), and to apply the same operation on the different sub-images, on different cores. Creating overlapping chunks is easy with the dedicated function view_as_windows (or view_as_blocks for contiguous non-overlapping chunks):  The joblib library enables easy parallel processing. Looping over the different blocks, and dispatching the computation over several cores, is realized with the following syntax: also offers experimental support for a more integrated parallel processing pipeline, thanks to the dask  [43]  module: The size of chunks is determined automatically from the number of available cpus, or can be specified by the user.
Caching provides another tool to speed up data analysis. A situation that often arises is that, while prototyping a workflow, scripts (containing the image processing pipeline) are run several times to experiment with parameters. joblib provides a caching mechanism that avoids the repetition of function calls, if their arguments have not changed:   [21]. Bottom totalvariation denoising of an image with two phases, corresponding to phase-separating silicate melts observed by in situ tomography  [7]. b Feature extraction-Top Hubble deep field (NASA, public domain), blob detection using the Laplacian of Gaussian method. Bottom ridge detection using the leading eigenvalue of the Hessian matrix, neuron image from CREMI challenge (https://cremi. org/data/). c Segmentation-Top super-pixel segmentation of a CT slice of the human head  [13] , using Felzenszwalb's algorithm  [18].
Documentation The quality of software documentation is (perhaps especially) important in software aimed at scientists. scikit-image users have access to several kinds of documentation. All functions are documented using the NumPy documentation standard  [35] , which is universal across all major Scientific Python packages. The standard includes a description of all input and output variables and their data types, together with explanations of what each function does and how to use it. Function documentation is accessible online or within the development environment itself (IPython, Spyder, Jupyter Notebook. ). In addition, a graphical gallery of examples (http:// scikit-image. org/docs/dev/auto_examples/), part of which is displayed Fig. 6 , showcases graphical examples of common image processing operations.
The examples are organized as an array of thumbnails with a short title (see Fig. 6 left ). These thumbnails link to the webpage of the corresponding example, which features a mini-tutorial on the image processing method, the code needed to run the example, and the figure generated by the example. Since the graphical gallery is an efficient way to inform users about the features of scikitimage, every new feature integrated in the package must include an example for the gallery. Longer tutorials and a more narrative documentation is available as well in the online User Guide of scikit-image. The User Guide explains in particular "big picture, " foundational aspects of scikit-image, such as its use of NumPy arrays as images, or how the package interacts with other parts of the scientific Python ecosystem.
Development and use of scikit-image Who uses scikit-image Estimating the number of active users of an open-source package is a difficult task. Download statistics, for example, largely overestimate the number of active users, all the more if the package is bundled with others in a software distribution, such as Anaconda or Canopy. A view closer to reality can be obtained by analyzing the statistics of visits of the online help, available on the project website. As of the first half of 2016, 20,000 unique visitors visited the scikit-image website every month at http://scikit-image. org/, from 138 countries. The scikit-image paper of 2014  [54]  has been cited by 120 research works (as of August 2016, according to Google Scholar), among which are studies that used X-ray imaging in fields such as medical imaging  [6, 30, 49] , materials science  [7] , or geoscience  [47].
Development process scikit-image is developed by a diverse team of volunteers. More than 170 individuals have contributed to the package. The large number of developers and users is key to project's sustainability. The development process takes place on GitHub https://github. com/scikit-image/scikit-image, where users and developers propose and discuss new contributions, report bugs, or submit ideas for improvements. A release cycle of one or two releases every year ensures that new features are propagated to users on a regular basis.
Discussion-current limitations and challenges While we emphasize the assets of scikit-image for processing X-ray images, one should be aware of current limitations. Speed of execution Although scikit-image approaches the speed of execution of compiled (C++, Java) code, it cannot reach the performance of code optimized for the GPU, or the hand-tuned CPU-specific optimizations found in OpenCV  [40]. At the moment, scikit-image is not the best tool for ultrafast computations where the workflow is known beforehand, simple, and stable. However, it is an excellent tool for exploring image data interactively and testing different algorithms-an important component of data processing in scientific work, and its speed of execution is sufficient for processing gigabyte-sized tomographic images in seconds to minutes.
Conclusions scikit-image offers a wide variety of image processing algorithms, using a simple interface natively compatible with 2D and 3D images. It is well integrated into the Scientific Python ecosystem, so that it interfaces well with visualization libraries and other data processing packages. scikit-image has seen tremendous growth since its creation in 2009, both in terms of users and included features. In addition to the growing number of scientific teams that use scikit-image for processing images of various X-ray modalities, domain-specific tools are now using scikit-image as a dependency to build upon. Examples include tomopy  [23]  for tomographic reconstruction or DIOPTAS  [39]  for the reduction and exploration of X-ray diffraction data. It is likely that more application-specific software will benefit from depending on scikit-image in the future, since scikitimage strives to be domain-agnostic and to keep the function interface stable.
Acknowledgements The authors gratefully acknowledge the work of the contributors of scikitimage, and thank  S. Deville  and  D. Vandembroucq  for a careful reading of the paper and useful suggestions. E. Gouillart acknowledges the support of  ANR  project  EDDAM ANR-11-BS09-027. CREMI (https://cremi. org/data/) is acknowledged for the membrane image of Fig. 5b.
This paper presents IRoSim: Industrial Robotics Simulation Design Planning and Optimization platform which we developed based on SolidWorks API. The main objective is to integrate features from mechanical and robotics CAD software into the same platform in order to facilitate the development process through a friendly interaction interface. The platform provides important steps to develop a given robotized task such as: defining a given task, CAD learning of the end-effectors' trajectory, checking the manipulator's reach-ability to perform a task, simulating the motion and preventing the trajectory from possible collisions. To assess the usability of the proposed platform, a car's doors painting task using a 6 Degree Of Freedom industrial manipulator has been developed.
IRoSim is accessible to anyone with basic knowledge of CAD and robotics. As shown in Figure  1 , the system offers users to simulate several steps to fulfill the desired objectives. IRoSim is integrated into SolidWorks and can easily be upgraded to future versions. Unlike programming packages  [3, 6] , IRoSim provides several features such as 3D design of the robotic manipulator, definition of the task to be accomplished, accessibility verification, optimization of the task time execution [7], graphical simulation, detection of the eventual collisions and generation of a collision-free trajectory to be directly ICIEA 2016 8 mapped to the real cell. In order to show the effectiveness of the proposed software we implemented a robotized task which is the painting (by dipping) using a 6-DOF robot manipulator.
CAD based approach Nowadays, the CAD model databases are widely used in the industry to design, model and programming robotics products  [3, 6]  such us AutoCAD, Ideas, Cimatron, CATIA and SolidWorks API (Application Programming Interface). We used this last to offer the feature to calculate the robotics task parameters based on a virtual 3D model of the real robotics cell. Moreover, the modification and the redefinition of these parameters are easily possible with the developed user-friendly integration.
Robotics library IRoSim platform includes a set of robot manipulators such as Staubli and KUKA KR6-2. 3D models of these manipulators can be integrated and assembled easily into SolidWorks; and the platform is open to integrate new manipulator models. Moreover, the library contains several other 3D tools that are needed for the simulation. Application (VBA). As shown in Figure  5 , we present it as Product Lifecycle Management (PLM) software that develop a set of stages (Figure  5 ) in order to allow the user to define, simulate and validate a given industrial robotics task, without exporting all models from the design environment to the simulation software.
CAD learning The proposed learning process is provided by GUI of IRoSim platform. We select first: a 3D CAD model of the task (e. g. , Figure  3  and 4 ) and a realistic 3D model of the EEF whose dimensions are specified in the main GUI of the IRoSim. User can move the 3D model of the EEF in the graphical area by translations and rotations around X, Y and Z axes using IRoSim's GUI. Then, we need to get the critical information that is helpful for learning more complex information from the graphical area. Figure  6  presents steps and pseudo-code to involve this process. Considering a P2P trajectory, we first get coordinates of the task points. From these point's coordinates we can extract the orientation at each point as the normal of the surface holding the point (i. e. , a coincidence constraint between the surface and the point).
Conclusion A novel CAD-based OLP platform IRoSim for industrial robots has been presented. A platform that is able to define, optimize, simulate and validate an industrial task and then map it into a real site. The proposed GUI of this platform is fully integrated with SolidWorks API and it provides many utilities that can cope with several industrial tasks including but not limited to; drilling, painting, spot welding, pick and place and other object manipulation tasks. Since the creation of the CAD models and robot programming task are performed in the same software the entire robot programming process becomes faster, easier and cheaper. In addition, the case of study of the painting task showed that the proposed platform is intuitive to novice use in industrial environments. In near future, we are looking forward to integrate some feedback control via cameras, sensors and other embedded systems.
Background Several R packages exist for the detection of differentially expressed genes from RNA-Seq data. The analysis process includes three main steps, namely normalization, dispersion estimation and test for differential expression. Quality control steps along this process are recommended but not mandatory, and failing to check the characteristics of the dataset may lead to spurious results. In addition, normalization methods and statistical models are not exchangeable across the packages without adequate transformations the users are often not aware of. Thus, dedicated analysis pipelines are needed to include systematic quality control steps and prevent errors from misusing the proposed methods.
Results SARTools is an R pipeline for differential analysis of RNA-Seq count data. It can handle designs involving two or more conditions of a single biological factor with or without a blocking factor (such as a batch effect or a sample pairing). It is based on DESeq2 and edgeR and is composed of an R package and two R script templates (for DESeq2 and edgeR respectively). Tuning a small number of parameters and executing one of the R scripts, users have access to the full results of the analysis, including lists of differentially expressed genes and a HTML report that (i) displays diagnostic plots for quality control and model hypotheses checking and (ii) keeps track of the whole analysis process, parameter values and versions of the R packages used.
Introduction DESeq2  [1]  and edgeR  [2]  are very popular Bioconductor  [3]  packages for differential expression analysis of RNA-Seq, SAGE-Seq, ChIP-Seq or HiC count data. They are very well documented and easy-to-use, even for inexperienced R users. In recent years edgeR and a previous version of DESeq2, DESeq  [4] , have been included in several benchmark studies  [5, 6]  and have shown to perform well in replicated experiments. However, running these packages, users can analyse their own dataset without entering important steps of the analysis process such as controlling the quality of the data, exploring its structure or checking some hypotheses of the statistical model. Although these steps are strongly recommended by the authors of the packages  [7] , they can be skipped by the users without stopping the analysis process.
In an attempt to provide a user friendly access to the whole analysis process of RNA-Seq data, the RNASeqGUI R package has been proposed to provide users with a graphical interface and help R beginners to run a differential analysis without writing R code  [8]. The analysis is divided into six main steps among which the pre-analysis section proposes no less than 12 possible figures to explore the data. Similarly, systemPipeR is a R package that proposes a pipeline to process raw fastq RNA-Seq reads from quality filtering to the alignment and counting and to perform a differential analysis using either the edgeR or DESeq2 package  [9]. Normalization is another key issue when looking for differentially expressed genes  [10]. The normalization methods associated with edgeR and DESeq2 have been shown to outperform other methods, in particular when expressed RNA repertoires vary across biological conditions or in the presence of highly expressed genes  [11].