Saravanan666/pypi-org huggingface dataset:
Package: scikit-surgeryopencvcpp
scikit-surgeryopencvcppscikit-surgeryopencvcpp implements image guided surgery algorithms, usingOpenCV, in C++ and wrapped in Python.scikit-surgeryopencvcpp is part of theSNAPPYsoftware project,
developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences,
part ofUniversity College London (UCL).FeaturesSupport for Python Wheels, thanks toMatthew Brett's multibuild.Triangulation usingHartley and Zisserman's method, and themidpoint of two lines.Surface reconstruction, usingDan Stoyanov'sMICCAI 2010 method, implemented inOpenCVbyDimitris Psychogyios.InstallingYou can pip install the latest Python package as follows:pip install scikit-surgeryopencvcppExamplesSurface Reconstructionpipinstallpptkopencv-pythonscikit-surgeryopencvcpppythonimportsksurgeryopencvpythonasskscvimportpptkimportnumpyasnpimportcv2left_image=cv2.imread('Testing/Data/reconstruction/f7_dynamic_deint_L_0100.png')right_image=cv2.imread('Testing/Data/reconstruction/f7_dynamic_deint_R_0100.png')left_intrinsics=np.loadtxt('Testing/Data/reconstruction/calib.left.intrinsic.txt')right_intrinsics=np.loadtxt('Testing/Data/reconstruction/calib.right.intrinsic.txt')l2r=np.loadtxt('Testing/Data/reconstruction/calib.l2r.4x4')rotation_matrix=l2r[0:3,0:3]translation_vector=l2r[0:3,3:4]points=skscv.reconstruct_points_using_stoyanov(left_image,left_intrinsics,right_image,right_intrinsics,rotation_matrix,translation_vector,False)points_3d=points[:,0:3]v=pptk.viewer(points_3d)DevelopingCloningYou can clone the repository using the following command:git clone https://github.com/UCL/scikit-surgeryopencvcpp.gitBuild instructionsStill not for the faint-hearted. It depends if you are a C++ developer familiar
with CMake or a hybrid C++/Python developer primarily interested in writing
Python extensions.The simplest advice really is to readappveyor.yml, as this will always
be up to date.Preferred Branching Workflow for Contributions.We welcome contributions to this project. Please use the following workflow.Raise issue in this project's Github Issue Tracker.Fork repository.Create a feature branch called<issue-number>-<some-short-description>replacing<issue-number>with the Github issue number
and<some-short-description>with your description of the thing you are implementing.Code on that branch.Push to your remote when ready.Create pull request.We will review code, suggest and required changes and merge to master when it is ready.DashboardsIn addition to Travis and Appveyor builds, C++ results are also
submitted to a publicCDashdashboard.Licensing and copyrightCopyright 2018 University College London.
scikit-surgeryopencvcpp is released under the BSD-3 license.
Please see thelicense filefor details.AcknowledgementsSupported byWellcomeand theEPSRC.The project was generated, usingCMakeCatchTemplateandCMakeTemplateRenamer.
Package: scikit-surgeryoverlay
scikit-surgeryoverlay is a python project that does interesting things.Author: Thomas Dowrickscikit-surgeryoverlay is part of theSNAPPYsoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).InstallingYou can pip install directly from the repository as follows:pip install git+https://weisslab.cs.ucl.ac.uk/WEISS/SoftwareRepositories/SNAPPY/scikit-surgeryoverlayDevelopingYou can clone the repository using the following command:git clone https://weisslab.cs.ucl.ac.uk/WEISS/SoftwareRepositories/SNAPPY/scikit-surgeryoverlayRunning the testsYou can run the unit tests by installing and running tox:pip install tox
toxContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2018 University College London.
scikit-surgeryoverlay is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgery-sphere-fitting
Author: Stephen Thompsonscikit-surgery-sphere-fitting is part of theSciKit-Surgerysoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).scikit-surgery-sphere-fitting supports Python 3.6.scikit-surgery-sphere-fitting fits a sphere to a set of 3D points. It includes a user interface that
will read data from a vtk polydata file create an output polydata file showing the fitted sphere.
Example usage:python sksurgeryspherefitting.py polydata_in.vtp --output polydatata_out.vtp --config conf.jsonIt was created in part to provide a simple demonstration of algorithm development as part of a
program of SNAPPY Tutorials, but also provides a useful service should you want to fit a sphere
to some data.CitingIf you use SciKit-Surgery-Sphere-Fitting in your research or teaching please cite it. Individual releases can be cited via the Zenodo tag above. SciKit-Surgery should be cited as:Thompson S, Dowrick T, Ahmad M, et al. “SciKit-Surgery: compact libraries for surgical navigation.” International Journal of Computer Assisted Radiology and Surgery. 2020 May. DOI:10.1007/s11548-020-02180-5.DevelopingCloningYou can clone the repository using the following command:git clone https://github.com/thompson318/scikit-surgery-sphere-fittingRunning testsPytest is used for running unit tests:pip install pytest
python -m pytestLintingThis code conforms to the PEP8 standard. Pylint can be used to analyse the code:pip install pylint
pylint --rcfile=tests/pylintrc sksurgeryspherefittingInstallingYou can pip install directly from the repository as follows:pip install git+https://github.com/thompson318/scikit-surgery-sphere-fittingor directly from pypipip install scikit-surgery-sphere-fittingContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2019 University College London.
scikit-surgery-sphere-fitting is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgerysurfacematch
Author: Matt Clarksonscikit-surgerysurfacematch is part of theSNAPPYsoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).scikit-surgerysurfacematch supports Python 3.6 - 3.8scikit-surgerysurfacematch contains algorithms that are useful in stereo reconstruction from video images, and matching to a pre-operative 3D model, represented as a point cloud.FeaturesBase classes (pure virtual interfaces), for video segmentation, stereo reconstruction, rigid registration / pose estimation. See`sksurgerysurfacematch/algorithms`A base class to handle rectification properly, and the right coordinate transformation, to save you the trouble.Stereo reconstruction classes based on Stoyanov MICCAI 2010, and OpenCV SGBM reconstruction, using above interface, and both allowing for optional masking.Rigid registration using PCL’s ICP implementation, which is wrapped in scikit-surgerypclcppA pipeline to combine the above, segment a video pair, do reconstruction, and register to a 3D model, where each part can then be swapped with whatever implementation you want, as long as you implement the right interface.A pipeline to take multiple stereo video snapshots, do surface reconstruction, mosaic them together, and then register to a 3D model. Again, each main component (video segmentation, surface reconstruction, rigid registration) is swappable. Inspired by: [Xiaohui Zhang’s](https://doi.org/10.1007/s11548-019-01974-6) method.DevelopingCloningYou can clone the repository using the following command:git clone https://github.com/UCL/scikit-surgerysurfacematchRunning testsPytest is used for running unit tests:pip install pytest
python -m pytestLintingThis code conforms to the PEP8 standard. Pylint can be used to analyse the code:pip install pylint
pylint --rcfile=tests/pylintrc sksurgerysurfacematchInstallingYou can pip install directly from the repository as follows:pip install git+https://github.com/UCL/scikit-surgerysurfacematchContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2020 University College London.
scikit-surgerysurfacematch is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgerytorch
Author: Thomas Dowrickscikit-surgerytorch is part of thescikit-surgerysoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).The aim of scikit-surgery torch is to provide a home for various pytorch models/examples/utilities that may be useful for Image Guided Surgery.FeaturesImplemented models:High Resolution Stereo networkInference only, see author’s repo for pre trained weights. As at commitaae0b9b.Volume2SurfaceCNNInferencece only, see author’s repo for pre trained weights. As at commit5a656381.Models can run on GPU or CPU.Example usage intests/.scikit-surgerytorch is NOT meant to be a layer on-top of pytorch
or provide a new kind-of platform. The aim is that researchers can learn from examples,
and importantly, learn how to deliver an algorithm that can be used by other people
out of the box, with just a`pip install`, rather than a new user having to
re-implement stuff, or struggle to get someone else’s code running.CloningYou can clone the repository using the following command:git clone https://github.com/UCL/scikit-surgerytorchRunning testsPytest is used for running unit tests:pip install pytest
python -m pytestLintingThis code conforms to the PEP8 standard. Pylint can be used to analyse the code:pip install pylint
pylint --rcfile=tests/pylintrc sksurgerytorchInstallingYou can pip install directly from the repository as follows:pip install git+https://github.com/UCL/scikit-surgerytorchContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2020 University College London.
scikit-surgerytorch is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgerytorsosimulator
Author: Stephen ThompsonSciKit-SurgeryTorsoSimulator has been superseded by SnappySonic.SnappySonic can be used as an ultrasound acquisition simulator. The output from a tracking system (NDI or AruCo tags) is to select a frame of pre-recorded video to show. A suitable video of ultrasound data is included in the data directory, however the user can select a video of their choosing. The software and its use is described in theSnappySonic paper.SnappySonic is part of theSciKit-Surgerysoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).SnappySonic supports Python 3.6.pip install snappysonic
python snappysonic.py --config config.jsonThe config file defines the tracking parameters and image buffer, e.g.{
 "ultrasound buffer": "data/usbuffer.mp4",
       "buffer descriptions": [
              {
               "name": "glove",
               "start frame": 0,
               "end frame": 284,
               "x0": 20, "x1": 200,
               "y0": 200, "y1": 260,
               "scan direction": "x"
              },
  ]
  ....
  "tracker config": {
              "tracker type": "aruco",
              "video source": 2,
              "debug": true,
              "capture properties": {
                      "CAP_PROP_FRAME_WIDTH": 640,
                      "CAP_PROP_FRAME_HEIGHT": 480

 }
}An example configuration file can be downloaded fromhereand an image buffer fromsource code repository data directoryDevelopingCloningYou can clone the repository using the following command:git clone https://github.com/UCL/snappysonicRunning testsUnit tests are performed in stand alone environments using tox, which also checks coding style.toxInstallingYou can pip install from pypi withpip install snappysonicor You can pip install directly from the repository as follows:pip install git+https://github.com/UCL/snappysonicHow to CiteIf you use this software in your research or teaching, please cite:Thompson, S., Dowrick, T., Xiao, G., Ramalhinho, J., Robu, M., Ahmad, M., Taylor, D. and Clarkson, M.J., 2020. SnappySonic: An Ultrasound Acquisition Replay Simulator. Journal of Open Research Software, 8(1), p.8. DOI:http://doi.org/10.5334/jors.289ContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2019 University College London.
snappysonic is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgerytrackervisualisation
Author: Stephen Thompsonscikit-surgerytrackervisualisation is part of theSciKit-Surgerysoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).scikit-surgerytrackervisualisation supports Python 2.7 and Python 3.6.scikit-surgerytrackervisualisation implements a basic interface for showing tracking output from a SciKit-Surgery tracker.python scikit-surgerytrackervisualisation.py
python scikit-surgerytrackervisualisation.py --config config.jsonPlease explore the project structure, and implement your own functionality.DevelopingCloningYou can clone the repository using the following command:git clone https://github.com/SciKit-Surgery/scikit-surgerytrackervisualisationRunning testsPytest is used for running unit tests:pip install pytest
python -m pytestLintingThis code conforms to the PEP8 standard. Pylint can be used to analyse the code:pip install pylint
pylint --rcfile=tests/pylintrc scikit-surgerytrackervisualisationInstallingYou can pip install directly from the repository as follows:pip install git+https://github.com/SciKit-Surgery/scikit-surgerytrackervisualisationContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2019 University College London.
scikit-surgerytrackervisualisation is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgeryultrasonix
scikit-surgeryultrasonixPython bindings for Ultrasonix machine.Only works on Windows with 32-bit version of Python.Tested with Python 3.7.PrerequisitesYou must have the Ulterius SDK on your local machine, and add thebinfolder to your system path.If sdk is inC:\Ulterius\sdk_612\binIn Windows CMDset PATH=%PATH%;C:\Ulterius\sdk_612\binIn Git Bashexport PATH=$PATH:/c/Ulterius/sdk_612/binExample Usageimport sksurgeryultrasonix
import numpy as np
import cv2

ip = "128.16.0.3" # This is the IP address of the Ultrasonix

U = sksurgeryultrasonix.Ultrasonix.CreateInstance()
U.connect_to_host(ip)

while True:

    frame = U.get_frame() # Returns numpy array
    frame = frame.reshape(480,640)
    cv2.imshow('x',x)
    cv2.waitKey(1)
Package: scikit-surgeryutils
Author(s): Miguel Xochicale, Thomas Dowrick, Stephen Thompson and Matt Clarkson;
Contributor(s): Mian Ahmad.scikit-surgeryutils containing small demo apps and utilities.scikit-surgeryutils is part of theSciKit-Surgerysoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).scikit-surgeryvtk is tested on Python 3.8. and may support other Python versions.FeaturesCommon overlay apps- Examples of common uses of scikit-surgeryvtk’s VTKOverlayWindow. Includes overlaying on a video feed, duplicating a feed.Command line applicationsOpen a terminal, load your virtual environment and run the application aspython sk*.py.sksurgeryvideolag.py - shows a millisecond timer and video image to crudely measure measure lag.sksurgerycharucotest.py - extracts charuco points and annotates video image with each id detected.sksurgeryrendermodelslikecamera.py - renders a VTK model, over background image, using OpenCV camera intrinsics.sksurgerymakecalibrationdots.py - Create a calibraiton dot pattern.sksurgeryreslice.py - DICOM reslice widget demo.sksurgerytextoverlay.py - VTK text overlay demo.sksurgerytransformpolydata.py - Read a surface mesh (.vtk,.vtp,.stl,.ply file), transform by 4x4 matrix and write as .vtk.InstallingYou can pip install directly from the repository as follows:pip install git+https://github.com/SciKit-Surgery/scikit-surgeryutilsDevelopingCloningYou can clone the repository using the following command:git clone https://github.com/SciKit-Surgery/scikit-surgeryutilsRunning the testsYou can run the unit tests by installing and running tox:pip install tox
tox
tox -e docs
tox -e lintEncountering Problems?Please get in touch or raise anissue.ContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2018 University College London.
scikit-surgeryutils is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgeryvideoutils
scikit-surgeryvideoutils is a python project containing a few test and demo
utilities, based around opencv-contrib-python for video processing and
PySide2 for GUI windows and widgets.sksurgeryvideolag.py - shows a millisecond timer and video image to measure lagsksurgerycharucotest.py - extracts charuco points and annotates video image with each id detected.scikit-surgeryvideoutils is part of theSNAPPYsoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).InstallingYou can pip install directly from the repository as follows:pip install git+https://weisslab.cs.ucl.ac.uk/WEISS/SoftwareRepositories/SNAPPY/scikit-surgeryvideoutilsDevelopingCloningYou can clone the repository using the following command:git clone https://weisslab.cs.ucl.ac.uk/WEISS/SoftwareRepositories/SNAPPY/scikit-surgeryvideoutilsRunning the testsYou can run the unit tests by installing and running tox:pip install tox
toxContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2018 University College London.
scikit-surgeryvideoutils is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-surgeryvtk
Author(s): Stephen Thompson, Matt Clarkson, Thomas Dowrick and Miguel Xochicale;
Contributor(s): Mian Ahmad.scikit-surgeryvtk implements VTK for Image Guided Surgery applications.scikit-surgeryvtk is part of theSciKit-Surgerysoftware project, developed at theWellcome EPSRC Centre for Interventional and Surgical Sciences, part ofUniversity College London (UCL).scikit-surgeryvtk is tested on Python 3.8. and may support other Python versions.FeaturesFunctionality includes:Load 3D surface modelsfrom vtl/stl/vtp etc. files.A widget to overlay3D models onto a background image e.g. from webcam/video file, useful for Augmented Reality (AR) overlays, using VTK.Functions for working withcalibrated cameras, and projecting points from 3D to 2D.A widget to drive astereo interlaced monitor.Functions tovoxelise data and calculate distance fields.InstallingYou can pip install as follows:pip install scikit-surgeryvtkDevelopingYou can clone the repository using the following command:git clone https://github.com/SciKit-Surgery/scikit-surgeryvtkRunning the testsYou can run the unit tests, build documentation, and other options by installing and running tox:pip install tox
tox
tox -e docs
tox -e lintEncountering Problems?Please get in touch or raise anissue.ContributingPlease see thecontributing guidelines.Useful linksSource code repositoryDocumentationLicensing and copyrightCopyright 2020 University College London.
scikit-surgeryvtk is released under the BSD-3 license. Please see thelicense filefor details.AcknowledgementsSupported byWellcomeandEPSRC.
Package: scikit-survival
scikit-survivalscikit-survival is a Python module forsurvival analysisbuilt on top ofscikit-learn. It allows doing survival analysis
while utilizing the power of scikit-learn, e.g., for pre-processing or doing cross-validation.About Survival AnalysisThe objective insurvival analysis(also referred to as time-to-event or reliability analysis)
is to establish a connection between covariates and the time of an event.
What makes survival analysis differ from traditional machine learning is the fact that
parts of the training data can only be partially observed – they arecensored.For instance, in a clinical study, patients are often monitored for a particular time period,
and events occurring in this particular period are recorded.
If a patient experiences an event, the exact time of the event can
be recorded – the patient’s record is uncensored. In contrast, right censored records
refer to patients that remained event-free during the study period and
it is unknown whether an event has or has not occurred after the study ended.
Consequently, survival analysis demands for models that take
this unique characteristic of such a dataset into account.RequirementsPython 3.8 or laterecosjoblibnumexprnumpy 1.17.3 or laterosqppandas 1.0.5 or laterscikit-learn 1.3scipy 1.3.2 or laterC/C++ compilerInstallationThe easiest way to install scikit-survival is to useAnacondaby running:conda install -c sebp scikit-survivalAlternatively, you can install scikit-survival from source
followingthis guide.ExamplesTheuser guideprovides
in-depth information on the key concepts of scikit-survival, an overview of available survival models,
and hands-on examples in the form ofJupyter notebooks.Help and SupportDocumentationHTML documentation for the latest release:https://scikit-survival.readthedocs.io/en/stable/HTML documentation for the development version (master branch):https://scikit-survival.readthedocs.io/en/latest/For a list of notable changes, see therelease notes.Bug reportsIf you encountered a problem, please submit abug report.QuestionsIf you have a question on how to use scikit-survival, please useGitHub Discussions.For general theoretical or methodological questions on survival analysis, please useCross Validated.ContributingNew contributors are always welcome. Please have a look at thecontributing guidelineson how to get started and to make sure your code complies with our guidelines.ReferencesPlease cite the following paper if you are usingscikit-survival.S. Pölsterl, “scikit-survival: A Library for Time-to-Event Analysis Built on Top of scikit-learn,”
Journal of Machine Learning Research, vol. 21, no. 212, pp. 1–6, 2020.@article{sksurv,
  author  = {Sebastian P{\"o}lsterl},
  title   = {scikit-survival: A Library for Time-to-Event Analysis Built on Top of scikit-learn},
  journal = {Journal of Machine Learning Research},
  year    = {2020},
  volume  = {21},
  number  = {212},
  pages   = {1-6},
  url     = {http://jmlr.org/papers/v21/20-729.html}
}
Package: scikit-talk
Badges(Customize these badges with your own links, and checkhttps://shields.io/orhttps://badgen.net/to see which other badges are available.)fair-software.eu recommendations(1/5) code repository(2/5) license(3/5) community registry(4/5) citation(5/5) checklisthowfairisOther best practicesStatic analysisCoverageDocumentationGitHub ActionsBuildSonarCloudCitation data consistencyHow to use scikit-talkShort description of packageThe project setup is documented inproject_setup.md. Feel free to remove this document (and/or the link to this document) if you don't need it.InstallationTo install scikit-talk from GitHub repository, do:git clone git@github.com:elpaco-escience/scikit-talk.gitcd scikit-talkpython3 -m pip install .DocumentationThe user documentation can be foundhere.
To read more about the aims of this software,this paperby Liesenfeldet al.(2021) describes the project in detail.ContributingIf you want to contribute to the development of scikit-talk,
have a look at thecontribution guidelines.CreditsThis package was created withCookiecutterand theNLeSC/python-template.