by

Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
  • Jan 28 2019 15:58
    bnorthan commented #557
  • Jan 25 2019 16:27
    gselzer commented #557
  • Jan 25 2019 08:37
    imagejan commented #592
  • Jan 25 2019 03:11
    HorizonP edited #592
  • Jan 25 2019 03:10
    HorizonP opened #592
  • Jan 22 2019 17:30
    ctrueden commented #591
  • Jan 22 2019 17:26
    haesleinhuepf edited #591
  • Jan 22 2019 17:19
    haesleinhuepf opened #591
  • Jan 21 2019 20:21
    dariomel edited #590
  • Jan 21 2019 20:20
    dariomel opened #590
  • Jan 21 2019 12:56
    bnorthan commented #557
  • Jan 21 2019 09:33
  • Jan 20 2019 14:05
    bnorthan commented #557
  • Jan 18 2019 22:53
    gselzer commented #557
  • Jan 18 2019 22:53
    gselzer commented #557
  • Jan 18 2019 20:12
    bnorthan commented #557
  • Jan 18 2019 19:50
    gselzer synchronize #557
  • Jan 18 2019 19:50

    gselzer on sharpen-smooth

    Add DefaultSmooth and DefaultSh… Preserve differentiation in sum… Rely on helper Ops to decrease … and 1 more (compare)

  • Jan 18 2019 19:14
    gselzer commented #557
  • Jan 18 2019 18:54
    gselzer synchronize #557
Gabriel Selzer
@gselzer
Hmm, I could also maybe make reifiedType the Type of the Op with type variables substituted, but that could cause confusion and could be a pain to determine that type. Also might be difficult if the Op is multiple Types or is some Type implementing one of our base types (like if we had a StatsOp that implemented Function)
Gabriel Selzer
@gselzer
@ctrueden do you remember if the fix-decon branch was essentially complete? Can I merge that work into imagej-rebase?
Curtis Rueden
@ctrueden
@gselzer I can't remember for sure, but it looks complete, except for history cleanup? I suggest you try to integrate it into migrate-imagej-ops ASAP.
Gabriel Selzer
@gselzer
I just finished merging @ctrueden
Curtis Rueden
@ctrueden
:+1:
Gabriel Selzer
@gselzer
@ctrueden still having trouble porting OpEvaluator. We do not have a way to call a Function using an array of arguments.
Cannot seem to think of a simple solution
Curtis Rueden
@ctrueden
@gselzer The solution talked about before was to have op adapters from each function arity to an NFunction.
Gabriel Selzer
@gselzer
@ctrueden hmm, you mean as in adapt Ops?
Gabriel Selzer
@gselzer
@ctrueden we have a couple of setUp methods in various Test superclasses (see here) that no longer work. Can we just leave these as @Before annotations, change the name to setUpTest so that it does not conflict with this, and remove the @Override annotation?
Curtis Rueden
@ctrueden
@gselzer If it works, do it. Or you can make a new test superclass. *shrug*
Miguel Vizoso
@MiguelVzs_twitter
dear all, I was wondering if someone knows how to tell the macro to recognize any digid in the title of my images
N0 = getTitle(); //N means name
imageToSelectString1 = substring(N0, indexOf(N0,"Position"), lastIndexOf(N0," "+number+" "));
this does not work
Curtis Rueden
@ctrueden
@MiguelVzs_twitter Could you please ask on forum.image.sc? This channel is for developer discussion of the ImageJ Ops library.
Curtis Rueden
@ctrueden
@frauzufall I recall us talking the other day about the behavior of computer ops, regarding preallocated output containers if they have preexisting data in them. Here is a relevant thread about that.
Deborah Schmidt
@frauzufall
Interesting, thanks @ctrueden !
Gabriel Selzer
@gselzer
@ctrueden So I am currently trying to big-number-proof this uniform noise IntegerType Op, but that is forcing me to use BigInteger for the math. Do you think this is overthinking things?
Curtis Rueden
@ctrueden
@gselzer The IntegerType itself has some math operations built in. Can you use those?
Gabriel Selzer
@gselzer
No, mostly because we need to define behavior for when the noise addition goes outside of the type range (and we don't know happens since the behavior across RealTypes is not consistent). I wrote about it in #554 , if you want a better explanation (when you have the time, of course)
Curtis Rueden
@ctrueden
I think we're going to go crazy trying to big-number-proof everything. Unfortunately.
We should probably just document the behavior for now.
If we want to do it completely properly, we would need to abstract all the math into interfaces...
Gabriel Selzer
@gselzer
Maybe we should type those two Ops on <T extends RealType<T> & NativeType<T>> and <T extends IntegerType<T> & NativeType<T>>?
Curtis Rueden
@ctrueden
Maybe. But even that is not enough to ensure that double-precision intermediate maths produce a reasonable result.
E.g. UnsignedLongType.
Gabriel Selzer
@gselzer
Aargh, I didn't think UnsignedLongType would implement NativeType. I had forgotten the definition of NativeType...
Curtis Rueden
@ctrueden
For multithreading something that needs random number generation, the steps are:
  1. Divide the problem into fixed-size units of work.
  2. Spawn N threads. For each thread:
while queue has more units of work:
    workUnit = queue.remove()
    for each pixel in constant-size block at workUnit.offset:
        noiseValue = workUnit.rng.next()
        pixel += noiseValue
3) Main thread waits for all child threads to terminate

Extra credit: instead of:

noiseValue = workUnit.rng.next()

You could do:

noiseValue = distroFunction.apply(workUnit.rng.next())
Where distroFunction is the noise function!
Joyce Lu
@Joyceluv4ever_twitter
Hi everyone! I have a question regarding accessing the exact data (numbers) of the plot lanes graph (Analyze -> Gels -> Plot lanes) so that I can analyze the peak location. Is this the place?
Curtis Rueden
@ctrueden
@Joyceluv4ever_twitter Please ask on forum.image.sc! It's a great forum with lots of experts who can help. This chat channel is for developer discussion of ImageJ Ops.
Joyce Lu
@Joyceluv4ever_twitter
Thanks!
Gabriel Selzer
@gselzer
@ctrueden I must have forgotten in the midst of all of the stuff we have talked about, what is the Ops threading strategy?
Curtis Rueden
@ctrueden
@gselzer The current strategy of ImageJ Ops? Or the intended one for scijava ops in future?
There isn't really a "current strategy", as you probably noticed.
Kyle I S Harrington
@kephale
all your threads are belong to us
Curtis Rueden
@ctrueden
The intended one for future is to lean on the ImgLib2 multithreading code, and never call getAvailableProcessors.
Gabriel Selzer
@gselzer
Ah, right
That was what I assumed @ctrueden, so I spent a bit of time looking at LoopBuilder yesterday
It seems nice as far as per-pixel operations go, however there are two things that would be nice for Ops that we cannot do:
(At least as far as I could tell with the small amount of time I spent with it)
  1. It only works on RAIs, whereas scijava-ops cannot work on RAIs. Of course, ImageJ-Ops can work on RAIs, and we can convert IIs to RAIs, not sure how slow that operation is
  2. It would be nice if Chunks had a bit more metadata (such as where they were in the image). This information is needed for our deterministic noise adders
Gabriel Selzer
@gselzer
I suppose we could use a BlockingQueue strategy to work on Iterables? Maybe that is not worth the trouble...
Gabriel Selzer
@gselzer
Hmm, maybe this conversation is better suited for the imglib2 channel
Although, imglib/imglib2#279 is kind of cool, and should fix my second issue listed above.
Curtis Rueden
@ctrueden
@gselzer Great, yes, please discuss in the imglib2 channel. Yes for (2): you can indeed localize within LoopBuilder loops, using that approach. For (1): "scijava-ops cannot work on RAIs"—you mean that we do not want scijava-ops to have a dependency on imglib2, right? So yeah, we should discuss with the ImgLib2 team whether to migrate the parallelization framework upstream of imglib2 into some very lightweight scijava-utils or scijava-parallelization thing.
Gabriel Selzer
@gselzer
Actually, @ctrueden, I am not sure that the PR I linked above is enough for what we need. We need to generate a MersenneTwister for every Chunk, but we do not have access to the Interval that the Chunk is operating on. This means we cannot use the min of the Interval to deterministically generate a seed