Closed ashwani-rathee closed 1 year ago
Hi Ashwani, thanks for your interest in JuliaImages!
Currently, demos in JuliaImages are managed by DemoCards. Existing demos are spreaded in multiple packages: juliaimages.github.io as the main doc, ImageFiltering.jl/docs for image filtering operations. The demos are written using a mixed Documenter markdown syntax, Literate julia syntax and DemoCards file syntax. You don't need to master all the syntax in the first go, as there are now many examples available for you to copy and modify. #144 is a good example of a demo PR.
We don't have a specific wish list of what demos should be added. It can be potentially dangerous for us to give a list as we're now "advanced" developers; things that are trivial to us might not be so trivial to others. For this reason, you can start with something simple based on your own decision and understanding.
Hey @johnnychen94 ,for the demos..is there any kind of preference for mosaicview over the plots.jl for showing the images??
mosaicview
is a very convenient and lightweight tool to preview multiple images in one-line of code. This is an advantage when making demos. Plots.plot
definitely works, but it is quite heavy a dependency so I'd try to avoid its usage.
If you look at the Project.toml
, you'll notice that Plots
is currently not included as the build dependency.
This is just a preference, if there's a use case that can only be covered by Plots.jl, then use it. For example, if you're going to show something like this, then use Plots:
Hey @johnnychen94 ,I was trying to put my demos in the juliaimages website code..I followed the instructions in guide on front page(https://github.com/JuliaImages/juliaimages.github.io). But errors were there that i `found
(base) ashwani@user:~$ cd julia-related/
(base) ashwani@user:~/julia-related$ cd juliaimages.github.io/
(base) ashwani@user:~/julia-related/juliaimages.github.io$ julia --project=. -e 'using Pkg; Pkg.instantiate()'
(base) ashwani@user:~/julia-related/juliaimages.github.io$ julia --project=. docs/make.jl
[ Info: SetupDemoCardsDirectory: setting up examples directory.
[ Info: SetupBuildDirectory: setting up build directory.
[ Info: Doctest: running doctests.
┌ Error: doctest failure in src/tutorials/conversions_views.md:312-332
│
After this part follows a long list of errors and warning and ends with:
│ These are docstrings in the checked modules (configured with the modules keyword)
│ that are not included in @docs or @autodocs blocks.
└ @ Documenter.DocChecks ~/.julia/packages/Documenter/3Y8Kg/src/DocChecks.jl:69
[ Info: Populate: populating indices.
[ Info: RenderDocument: rendering document.
[ Info: HTMLWriter: rendering HTML pages.
┌ Warning: invalid local link: unresolved path in function_reference.md
│ link.text =
│ 1-element Array{Any,1}:
│ "Equalization"
│ link.url = "@ref"
└ @ Documenter.Writers.HTMLWriter ~/.julia/packages/Documenter/3Y8Kg/src/Writers/HTMLWriter.jl:1794
┌ Warning: invalid local link: unresolved path in function_reference.md
│ link.text =
│ 1-element Array{Any,1}:
│ "Maurer et al., 2003"
│ link.url = "DOI: 10.1109/TPAMI.2003.1177156"
└ @ Documenter.Writers.HTMLWriter ~/.julia/packages/Documenter/3Y8Kg/src/Writers/HTMLWriter.jl:1794
[ Info: Redirect URL: redirect docs-edit-link for demos in examples directory.
┌ Warning: Documenter could not auto-detect the building environment Skipping deployment.
└ @ Documenter ~/.julia/packages/Documenter/3Y8Kg/src/deployconfig.jl:75
And it's not being deployed for me to check,even when I haven't added anything to it yet..pls guide
you could find the built documentation in docs/build/index.html
, open it in chrome or whatever web browser.
so @johnnychen94 it will update automatically when I add the demos and run this code ,right??and the index.html worked fine as expected
correct, after you succesfully see docs/build/index.html
file, you can add your new demo files in docs/examples
. DemoCards detects whatever the demos you added, preprocess, and then pass to Documenter.
@johnnychen94 I was a little confused by the build_histogram after I get the values,do I have to build the histogram myself from the output or am I missing anything?
Is there a space for demo on image binarization here??I will do it using the methods in Image Binarization Package
ImageBinarization has an overly detailed explanation in the docstring. My personal idea is to set up a new demo page in ImageBinarzation's own documentation (not here), and move those explanations from docstrings to demos. In the future, we could gather all those cards into this repo with the help of https://github.com/johnnychen94/DemoCards.jl/issues/72
Is there need for demo for creating ImagePyramids?ImagePyramids are used to implement algorithms for denoising, texture discrimination, and scale-invariant detection like here
Since you're adding a bunch of demos, I'd like to introduce you to preview_demos("demo_file.jl")
or preview_demos("path/to/demos_dir")
if you haven't try it. This saves a lot of building time when we iteratively modify the codes and see the output page.
See also: https://johnnychen94.github.io/DemoCards.jl/stable/preview/#Example-%E2%80%93-JuliaImages
There are several ways to create Imags pyramids that I found:
num=5
img_source = testimage("woman_darkhair")
pyramid = gaussian_pyramid(img_source, 5, 2, 1)
# img=PaddedView(Gray(0.2),pyramid[2], (512, 256))
finalimg=PaddedView(Gray(0.2),pyramid[1], (512, 512))
for i in 2:num
img=PaddedView(Gray(0.2),pyramid[i],(512,size(pyramid[i],1)))
global finalimg=hcat(finalimg,img)
end
plot(finalimg)
I like this one as there is lot of parameters that can be put into loops...and can be general
#A simple image pyramid
img_source = testimage("woman_darkhair")
pyramid = gaussian_pyramid(img_source, 5, 2, 1)
mosaicview(pyramid[1],pyramid[2],pyramid[3],pyramid[4],pyramid[5];nrow=1,center=false)
imgsource = testimage("woman_darkhair")
finalplot = plot(
axis = nothing,
layout = @layout([a [b [c [d;_]; _]; _]]),
size = (800,400)
)
for i=1:4
plot!(finalplot[i], imgsource, ratio=1)
end
finalplot
There are many other ways with various plotting libraries which uses subplots or something related to it,so similar to plots one only.Did I miss the best way??which one should I use??
The current mosaicview
is built based on paddedviews
and sym_paddedviews
, whose outputs are of the same size. For the purpose of pyramid visualization, it makes sense to visualize as your option 1 does.
Instead of providing some dirty for loop in the demo, I think a better way is to improve how mosaicview
works. Here's what I have in mind:
dims
keyword to paddedviews
and sym_paddedviews
to specify we only want dims
dimensions to be padded.dims
keyword to mosaicviews
.The dims
keyword should follows the same options as cat
s do, that all of dims=1
, dims=(1, 2)
and dims=1:2
are valid values. To be backward-compatible, we need to make the default option dims=1:ndims(first(As))
.
mosaicview(pyramid; nrow=1, center=false, dims=1)
is what I have in mind; that we only pad along the height dimension.
Do you want to try this? This should be quite interesting to do.
yes,I want to give this a try.
I would also suggest mentioning restrict
, which blows gaussian_pyramid
away for 2x reductions:
julia> @btime gaussian_pyramid($img, 4, 2, 2);
5.563 ms (1026 allocations: 8.12 MiB)
julia> @btime (pyr = [img]; for i = 1:3 push!(pyr, restrict(pyr[end])) end)
244.973 μs (37 allocations: 1.08 MiB)
Hey @johnnychen94 @zygmuntszpak ,I was working on canny edge detector demo using ImageEdgeDetection.jl The demo started working just fine with Images.canny and the way I solved with it.
using Images, FileIO, ImageShow, ImageFiltering
using TestImages,ImageFeatures
using ImageTransformations,CoordinateTransformations
using Rotations,OffsetArrays,MosaicViews
img_gray = zeros(Gray{Float64}, 200, 200)
img_gray[50:150, 50:150] .= 1
tfm = recenter(RotMatrix(pi/8), center(img_gray))
imgrot = warp(img_gray, tfm) |> parent
imgg = imfilter(img_gray,Kernel.gaussian(4))
#imgg = imfilter(imgrot, Kernel.gaussian(3))
imgg += 0.2*rand(Gray{Float32}, size(imgg))
imgfinal=Gray.(imgg)
img_edges = canny(imgfinal,(Percentile(80),Percentile(20)),1)
img_demo = Float64.(img_edges);
[imgg Gray.(img_demo)]
mosaicview(imgfinal,img_edges;nrow=1)
After seeing that @zygmuntszpak has registered new package,I wished to use that.
@zygmuntszpak solved most of it but I am stuck with creating random noise in image which I wanted to use to show significant difference in results of sigma being 1 and 3 respectively
I was trying to add random noise after applying gaussian filter.
Any Idea how to solve this or what I am doing wrong??
Well,this rather simple issue can be solved by using Noise.jl by @roflmaostc ,rather than messing with the offset arrays
I noticed something rather unexpected in here
some salt_pepper helped in getting what I wanted,but what is happening out the image area which is padded,isn't it black only??or (Gray 0 )
imgg += 0.2*rand(Gray{Float32}, size(imgg))
As suggested by the error message, the reason this doesn't work is that imgg
has indices that run from -30:231
whereas the matrix of random noise that you wish to add has indices that run from 1:262
. The addition is undefined because you need the indices to match for all elements of the array. One way to resolve this involves changing the indices for the noise array by wrapping it with an OffsetArray. For example,
using OffsetArray
imgg = imgg + OffsetArray( 0.2 * rand(Gray{Float32}, size(imgg)), axes(imgg)...)
Another approach is to write this all as a loop instead
for i in CartesianIndices(imgg)
imgg[i] = imgg[i] + 0.2*rand(Gray{Float32})
end
Or with map!
map!(x-> x + 0.2*rand(Gray{Float32}), imgg, imgg)
Another thing to keep in mind is that you probably want the values to remain within the unit interval. Hence, you might try something like this:
for i in CartesianIndices(imgg)
imgg[i] = clamp01(imgg[i] + 0.2*rand(Gray{Float32}))
end
I noticed something rather unexpected in here some salt_pepper helped in getting what I wanted,but what is happening out the image area which is padded,isn't it black only?
Thanks for investigating this. I've done some digging and noticed that neither my implementation in ImageEdgeDetection
nor the current implementation in Images
correctly handles data with NaN
entries. The issue can be pinned to the fact that both implementations use the following code to Gaussian filter the image:
# Smooth the image with a Gaussian filter of width σ, which specifies the
# scale level of the edge detector.
kernel = KernelFactors.IIRGaussian((σ,σ))
imgf = imfilter(img, kernel, NA())
I'm not sure if this is by design, or whether it is a bug, but the KernelFactors.IIRGaussian((σ,σ))
implementation does not leave the NaN
values untouched but returns what seem to be spurious values in the NaN
region. Consequently, when one computes the gradient one obtains a gradient response in those regions, which in turns cause canny to detect edges there as well.
If I switch my implementation to
kernel = KernelFactors.gaussian((σ,σ))
imgf = imfilter(img, kernel, NA())
the issue is avoided and everything works as it should. However, the KernelFactors.IIRGaussian((σ,σ))
version is supposed to be faster so there is likely a small performance penalty.
I will switch the implementation in ImageEdgeDetection
and tag a new release to resolve this issue.
How big is σ
? If it's just a couple of pixels it shouldn't matter much, and will also be more accurate.
σ I used is 4
The default value of σ
is usually small (between 1 and 2) pixels, so glad to hear Tim confirm that it shouldn't be too much of an issue.
If anything it's probably better to avoid IIRGaussian below 2.
@ashwani-rathee I've tagged and released a new version of ImageEdgeDetection
which should now solve the issue you were having with the NaN values.
Hey! I am Shiven, a sophomore at IITK. I also looked through the previous JSoC projects, and, would love to contribute some demos myself! I had a question on this, on [https://juliaimages.org/stable/], there's a separate section for demo cards while for some packages the demos are included in the docs. (like it is pretty obvious how to use Watershed for segmentation from[https://juliaimages.org/stable/pkgs/segmentation/], even though it does not have a demo card.)
I guess the demos for using those packages won't be needed to be written afresh? From what the project proposal mentioned it seemed like the idea for Demo Cards is to organise everything together, right?
Hey @ShivenTripathi,what I understood from @johnnychen94 is that those demos maybe edited/changed or kept same depending on each case.Project idea is to kind of collect and showcase them in one organised place with democards.
Democards.jl is written by @johnnychen94 to kind of dynamically generate demos and associated assets with it.Since the examples in other place are written with different tools and format,we kind of need to rewrite them to work with democards.#144 is a good example of a demo.
@johnnychen94 @timholy @zygmuntszpak I want to keep working on JuliaImages and surely more regularly than I'm currently working on this. I had several doubts regarding the projects for GSoC after the organization's list has been released . I think since my research interests are going into classification problems like classification of microbes in water bodies that help determine the water quality in the area, it would also help me in that section as you people are researchers yourselves, and help me figure out this path. I am starting to work with my teammate mentored by one of my profs and continuing the previous work on this:https://www.mdpi.com/1099-4300/23/2/257/pdf which requires lots of image processing techniques like convolution filters, segmentation, convex hull, etc...
Can you clarify my GSoC-specific doubts?
Some of my recent projects can be seen here:
I'm glad that you're interested in GSoC. This is a brief reply in a hurry but I hope it answers some of your doubts.
GSoC 21 is quite different from previous years since it cuts the timeline from 18 weeks to 10 weeks. The project ideas listed on https://julialang.org/jsoc/ are mostly added years ago so it may not suit this year. In very short words, a potential GSoC project should:
and of course, the project should be something that you enjoying spending time on. Ideally, you can propose some project that you're working on already, and this project happens to benefit other people in the Julia community. For example, if it is some missing application or functionalities in Julia, great.
Having a mentor is the most important thing in applying GSoC as if a project has no mentor, it's an invalid project even if it is a good one. The project should benefit others because this is why GSoC is here; students contribute codes to benefit others, mentors provide guidance, review, and help. If a project is only a personal research interest that few people in the community is interested in, it's less likely to find a mentor. Again, finding a mentor is the most important thing.
Currently, JuliaImages has only three active members. My major interest is in low-level image processing. @timholy is a Julia wizard but from what I've known, he doesn't know much of CV things, too. @zygmuntszpak knows a lot of CV things but he's busy with daily work so may not be available. This is why CV packages are not very well nor actively developed in JuliaImages.
Said this, if you want to know how JuliaImages is designed and how to use JuliaImages, we'll be very pleased to offer help, but if it's related to the very specific details in a very specific field, I'm afraid that we're lacking the knowledge to help with that.
I was a GSoC 19 student (you can find my proposal and report in https://github.com/johnnychen94/GSoC2019), I benefit a lot from the blog http://www.stochasticlifestyle.com/tips-google-summer-code-application/ and I would recommend you to read it carefully, too.
How it's decided which project will be worked upon?
You propose an idea that some of us find interesting and provide proof that you're capable of finishing it. The mentor is more like a supervisor; he may not answer every question or solve every difficulty you have.
I am thinking of writing my proposal in latex with overleaf.com which could be seen here: https://www.overleaf.com/read/gfjrnqjwcrds Can you people help me with it and view it every once in a while to give me some feedback?
Of course, but we won't view it every once in a while. Feel free to ping us when you need a check. The point is, if you save our time, we save yours. 😃
I am not entirely sure if I should ask this question, even though I code regularly with my teams participating in hackathons and I try to help people in open source ( I am a mentor in gssoc'21 :), so many people asking for PR merges and assignment ), but I feel I haven't contributed enough (to JuliaImages specifically) to show I am somewhat proficient in Julia/programming...what do you people think? what are your expectations? What should I change?
According to my reviews on your previous demo PRs, I feel that you're still a JuliaImages' user instead of a developer. You can quickly come up with some codes, but being a JuliaImages developer, one should try to introduce more functionalities that were missing(of course, based on his own need since we're contributing freely). The codes you provided are still very trivial to me.
I would be very excited to see some progress in https://github.com/JuliaArrays/MosaicViews.jl/issues/24. This is not a trival one but is still doable if you put some time into it.
Would the project be a single project listed on website or an amalgamation of multiple projects that best suits the timeline?
I've seen both kinds of GSoC projects in past years so it only depends on how you propose it. Even for a single project, it's often the case that you break it into several small and connected projects.
Just FYI some time ago I updated that project list to reflect the changes this year. The long-term goals aren't different than before but I tried to specify a "minimum needed to declare victory" that I hoped was not insanely ambitious.
The decisions for student selection are based largely on a combination of enthusiasm for the trainee and the project. I would say that the trainee matters more than the project, so putting together a well-conceived proposal and demonstrating that we'll be able to work with you are good ways of increasing your chances.
@johnnychen94 @timholy @zygmuntszpak I am currently thinking of adding around 20 new demos(also solving function related issues that come with it and help in add some new functionalities too like dims,fill,thickness issues in ImageDraw.jl),restructuring some old ones into better pieces,bringing relevant demos in various repos of JuliaImages to central JuliaImages demos base. Is it too little workload or too much for proposal? Solving function related issues will surely take much more time and effort than making demos tbh :) Timeline is still a work in progress but I'll keep updating this one: :)https://timelines.gitkraken.com/timeline/1e482e7164d9452eb59212d39ebc6c27 Demos samples: Kind of recreating atleast the code for those examples(it doesn't includes the markdown/explaining part) https://github.com/ashwani-rathee/Demos
Adding plenty of demos definitely helps a lot. However, I encourage you to slow down a bit and focus on adding missing functionalities. Here's my consideration:
From your side point of view, participating GSoC is a good chance to get your code reviewed by people who already know Julia well so that you know the taste of Julia better and will be more likely to write reliable and performant Julia codes. Adding simple demos will reduce your chances to be reviewed since it's more of English technical writing training instead of programming training. We want you to benefit more from the GSoC festival rather than get you to contribute things.
From our side, people pass in and out and we really wish that we can get more potential developers and maintainers of Julia and Julia packages. GSoC is a great opportunity for us since it invites new talented students here to learn and to contribute codes. I was GSoC 18 student and I've become the maintainer of JuliaImages since that. We haven't had any new faces here and I really hope you're the next.
Hence, I feel about 5-10 demos should be enough and I feel you should focus more on adding missing functionalities to the Images toolbox. I sincerely want you to learn more by asking you to do some non-trivial work.
I'm pretty sure that I'll not be available as a mentor this summer since I plan to participate in GSoC in the halide community. Google says that one cannot be both a student and a mentor so my name can't be put in your proposal. But of course, I'll still be around to offer "unofficial" reviews and feedbacks.
@johnnychen94 I really hope it works for you there in halide community and let's see how it works for me.It always works out just fine.Though with the choice of content that goes in my timeline that part really needs some rethinking.
@johnnychen94 Can you give an idea on how the image restoration algorithms in Julia Images are organised ? I think some of them are in imagefiltering.jl though not most of them Like :
Unfortunately, as far as I know, none of them are formally available in JuliaImages yet...
@ashwani-rathee I've seen your passions throughout all the discussions in the issues you opened. That's a good thing, yet I still have some words to say about it and the GSoC application you're preparing:
The first thing is about pinging others with @. There are three scenarios that we ping others.
However, ping others would automatically make them subscribed to the discussion and will send endless emails to their mail boxes. Depending on how people feel about it, this can become a spam if not under controlled. For this very specific reason, I suggest that you only ping others when there's a real need. We ping people to emphasize the priority of the issue, but if you ping people for every issue you opened, then you end up with emphasizing nothing.
The second thing is about your independence. As I've said in my earlier reply, a GSoC student would be independent enough to finish his project by himself. Mentor is only a supervisor that makes sure you're working and targeting correctly; he only provides limited guides during the period. We emphasize independence because for open source development, people are not responsible to reply to you, so in many cases, you have to do things by your own.
The bad news for you is that I'm still not confident about this. I haven't seen you working out the feature PRs so prove that you're capable of doing things independently.
I'm still watching, but if it is still the case by the time when people evaluating your proposal, it would be very likely that you're rejected because of not being independent.
Okay,I didn't knew that @ would be an issue.I will stop that,though it wasn't intentional to catch attention...
You also mentioned that I'm not being independent enough(maybe it's my anxiety that makes me need more conversation than open source usually offers). I try to make demos as it's a project I wish to work for this year.It's not that I can't make feature PRs,but I feel the examples section needs far more work to show the capabilities of JuliaImages(low hanging fruit)...I'm still developing a taste for the JuliaImages(and Julia tbh) and demos is the way I wish to get familiar to each section of JuliaImages as I get to work on different sections and find their weaknesses and strengths that set path for me for future work :)
Also I'm not entirely sure now if there will be a mentor for this project but I didn't want to work on a project that I'm completely unfamiliar with and don't know anything about with well written proposal.So I think I'll stick with what I know(usually not what I say),see what happens and it usually works out just fine.. Since I'm just in 2nd year rn,I definitely need more active community to grow than I currently have here.I would appreciate more guidance .
No worries, I believe you're not intentional and nobody will blame you on this. Because most people have their daily work and are usually quite busy, the key convention in the open-source world is that "if you save our time (e.g., by giving detailed and reproducible bug reports, easy-to-review PR, well-organized proposal), then we will save yours (e.g., by fixing bugs, providing feedbacks)". If you keep this "rule" in mind, I believe you'll get more and more valuable feedback from others.
I'm still developing a taste for the JuliaImages(and Julia tbh) and demos is the way I wish to get familiar to each section of JuliaImages
Yes, I can see that. This is also how I learned Julia and JuliaImages, too; I developed DemoCards during that period to make writing demos a maintainable work.
Also I'm not entirely sure now if there will be a mentor for this project
@timholy is quite busy recently with his daily work but he said that he'll be available as a mentor. I hope he could be your mentor. But again, you have to show that you can work independently; otherwise, we're abusing our community reputation by recommending you.
Since I'm just in 2nd year rn,I definitely need more active community to grow than I currently have here.I would appreciate more guidance .
I actually had a brief talk with @zygmuntszpak a few days ago and we both believed that if you keep this passion and get involved in JuliaImages, then you'll definitely get a seat next year. I hope you can get a seat this year but I'm not very confident about that yet.
@timholy @johnnychen94 @zygmuntszpak
I'd like to hear feedback from you people on the draft proposal
Can be viewed from here: https://www.overleaf.com/read/gfjrnqjwcrds
For editing, I have sent emails directly to active members for review on the first draft...I can send an email to any other member of JuliaImages if they wish to review
Dr. Zygmunt, I wasn't able to find your email on GitHub, so sent an email to
zygmunt.szpak@ivai.com.au
as mentioned in the website linked
sorry for the late draft, but I have been sick for the past week on and off..so that slowed down things quite a lot It's being constantly updated, with each iteration(I'll fix issues of formatting, grammatical and particular details). Since the ecosystem is huge, I was able to find a lot of good+reasonable ideas, though I have commented out a lot of them to fit the timeline. If possible can you people cover below-mentioned points and suggest changes on:
Contributions have been mentioned in the draft but I have done some other relevant work that I would like to mention :) Demonstrations :https://github.com/ashwani-rathee/Demonstrations relevant benchmarking work:https://docs.google.com/spreadsheets/d/1phJFNtj8J1pte3h-oLMCQwRAO6Ot_yeaGcDCGi9hvXI/edit?usp=sharing
Disclaimer: I'm not a potential mentor so it requires @timholy and @zygmuntszpak to confirm.
ImageBinarization: What if I don’t know which one is best algorithm for my specific use case?How to check that fast?
A good observation. I'm also curious about how to appropriately choose between different algorithms.
ImageContrastAdjustment it would be a good idea to take a matrix and show the effect of all the algorithms in one place.
:+1:
Regardless of the accuracy of your written English, which I'm not confident to judge, a space is required after punctuation. Not following this rule makes the words uncomfortable to read.
- I plan to implement 10 -15 demos(depends on if we wish to combine multiple operations in single demo,and how compact we want the demos and functions in them to be).I’ll go in detail about which part deserve space on demos section of JuliaImages with help of DemoCards.jl.I will go into the discussion for each package provided and where it fits in demos.
+ I plan to implement 10 -15 demos(depends on if we wish to combine multiple operations in single demo, and how compact we want the demos and functions in them to be). I’ll go in detail about which part deserve space on demos section of JuliaImages with help of DemoCards.jl. I will go into the discussion for each package provided and where it fits in demos.
The efforts you paid improving the documentation and easy-usability is really appreciated. The thing I'm going to say might just be differences between tastes and preferences. It totally depends on how you think of it. One thing that might worth noting is, as officially provided demos and codes, they're very likely to be treated as the recommended way of coding and get copied around. Hence we need to write concise and efficient codes when we write demos. The long and verbose codes are only used when we want to break things apart and explain how things works. As an example, I would recommend one of my median filter demo in ImageFiltering, the purpose there is to explain how to use mapwindow(median, img, patch_size)
. I showed how to manually implemented a simple version of such functionality, and then showed how the job can be done easily and efficiently with mapwindow
, in the end I gave an example of median
filter that might be useful in real world application.
Is there anything I completely overlooked?
Images in JuliaImages are just colorant arrays, so there might be many algorithms and packages outside JuliaImages that works on images. Packages such as PaddedViews
, MappedViews
, OffsetArrays
are designed in a generic way to support image processing pipelines.
TiledIterations
is a package that design to assist tile/patch processing, which usually occurs in image filtering pipeline. Adding an example of how to use it would be quite helpful, I think.
You can, of course, hang around and see if there're other packages in Julia that can be useful.
Does the timeline looks reasonable?
Generally good to me. As you may have noticed, open source development is usually asynchronous, so you can't expect that you are working demos one by one in a sequential way. For evaluation purposes, it's okay to list them as it is right now, but it would be helpful to add an comment there, e.g., "depending on how PR review progresses, some demos might take longer to be added/merged".
The thing I'm going to say might just be differences between tastes and preferences. It totally depends on how you think of it. One thing that might worth noting is, as officially provided demos and codes, they're very likely to be treated as the recommended way of coding and get copied around. Hence we need to write concise and efficient codes when we write demos. The long and verbose codes are only used when we want to break things apart and explain how things works. As an example, I would recommend one of my median filter demo in ImageFiltering, the purpose there is to explain how to use
mapwindow(median, img, patch_size)
. I showed how to manually implemented a simple version of such functionality, and then showed how the job can be done easily and efficiently withmapwindow
, in the end I gave an example ofmedian
filter that might be useful in real world application.
I understand it's about taste/efficiency.With your comments and time on PRs,I am slowly and steadily developing a taste on how to do things,a month before:
Thank you for reviewing,I'll update the proposal with the points you mentioned
@timholy @johnnychen94 @zygmuntszpak I think I am close to a final proposal ,would like to hear feedback from you people on this version of proposal Github: https://github.com/ashwani-rathee/GSOC-21-proposal Overleaf: https://www.overleaf.com/read/gfjrnqjwcrds
Curious to ask, do you by any chance know the GSoD event? https://julialang.org/blog/2021/04/gsod-2020-wrapup/
@johnnychen94 Actually I do,I do follow its schedule
I think GSOC, OSPP are done and dusted by my side, closing this now to do better things
Hey Guys,I am Ashwani Rathee,undergraduate cs student at UIET,Panjab University,India Saw this on: https://julialang.org/jsoc/gsoc/images/ I have explored JuliaImages in past: https://github.com/ashwani-rathee/Learning-Julia/blob/master/ImageProcessing%20in%20Julia.ipynb And would love to contribute through examples: @timholy and @zygmuntszpak guide me on this and give me some direction to work on:)